diff options
Diffstat (limited to 'package/qa/storages')
38 files changed, 9415 insertions, 0 deletions
diff --git a/package/qa/storages/BorderedStream.java b/package/qa/storages/BorderedStream.java new file mode 100644 index 000000000000..7972b7a3ef0a --- /dev/null +++ b/package/qa/storages/BorderedStream.java @@ -0,0 +1,195 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; +import com.sun.star.io.XOutputStream; +import com.sun.star.io.XTruncate; +import com.sun.star.io.XSeekable; + + +public class BorderedStream + implements XStream, XInputStream, XOutputStream, XTruncate, XSeekable +{ + int m_nMaxSize; + int m_nCurSize; + int m_nCurPos; + byte m_pBytes[]; + + public BorderedStream( int nMaxSize ) + { + m_nMaxSize = nMaxSize; + m_nCurSize = 0; + m_nCurPos = 0; + m_pBytes = new byte[m_nMaxSize]; + } + + //============== + // XStream + //============== + + // ---------------------------------------------------------- + public synchronized XInputStream getInputStream() + throws com.sun.star.uno.RuntimeException + { + return (XInputStream)UnoRuntime.queryInterface( XInputStream.class, this ); + } + + // ---------------------------------------------------------- + public synchronized XOutputStream getOutputStream() + throws com.sun.star.uno.RuntimeException + { + return (XOutputStream)UnoRuntime.queryInterface( XOutputStream.class, this ); + } + + //============== + // XInputStream + //============== + + // ---------------------------------------------------------- + public synchronized int readBytes( byte[][] aData, int nBytesToRead ) + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + int nRead = 0; + if ( m_pBytes != null && nBytesToRead > 0 ) + { + int nAvailable = m_nCurSize - m_nCurPos; + if ( nBytesToRead > nAvailable ) + nBytesToRead = nAvailable; + + aData[0] = new byte[nBytesToRead]; + for ( int nInd = 0; nInd < nBytesToRead; nInd++ ) + aData[0][nInd] = m_pBytes[m_nCurPos+nInd]; + + nRead = nBytesToRead; + m_nCurPos += nRead; + } + else + { + aData[0] = new byte[0]; + } + + return nRead; + } + + // ---------------------------------------------------------- + public synchronized int readSomeBytes( byte[][] aData, int nMaxBytesToRead ) + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + return readBytes( aData, nMaxBytesToRead ); + } + + // ---------------------------------------------------------- + public synchronized void skipBytes( int nBytesToSkip ) + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + if ( nBytesToSkip < 0 ) + throw new com.sun.star.io.IOException(); // illegal argument + + if ( m_nCurSize - m_nCurPos > nBytesToSkip ) + m_nCurPos += nBytesToSkip; + else + m_nCurPos = m_nCurSize; + } + + // ---------------------------------------------------------- + public synchronized int available() + throws com.sun.star.io.NotConnectedException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + return 0; + } + + // ---------------------------------------------------------- + public synchronized void closeInput() + throws com.sun.star.io.NotConnectedException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + // no need to do anything + } + + + //============== + // XOutputStream + //============== + + // ---------------------------------------------------------- + public synchronized void writeBytes( byte[] aData ) + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + if ( m_pBytes != null && aData.length > 0 ) + { + if ( aData.length > m_nMaxSize - m_nCurPos ) + throw new com.sun.star.io.IOException(); + + for ( int nInd = 0; nInd < aData.length; nInd++ ) + m_pBytes[m_nCurPos+nInd] = aData[nInd]; + + m_nCurPos += aData.length; + if ( m_nCurPos > m_nCurSize ) + m_nCurSize = m_nCurPos; + } + } + + // ---------------------------------------------------------- + public synchronized void flush() + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + // nothing to do + } + + // ---------------------------------------------------------- + public synchronized void closeOutput() + throws com.sun.star.io.NotConnectedException, com.sun.star.io.BufferSizeExceededException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + // nothing to do + } + + + //============== + // XTruncate + //============== + + // ---------------------------------------------------------- + public synchronized void truncate() + throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + m_nCurSize = 0; + m_nCurPos = 0; + } + + + //============== + // XSeekable + //============== + + // ---------------------------------------------------------- + public synchronized void seek( long location ) + throws com.sun.star.lang.IllegalArgumentException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + if ( location > (long)m_nCurSize ) + throw new com.sun.star.lang.IllegalArgumentException(); + + m_nCurPos = (int)location; + } + + // ---------------------------------------------------------- + public synchronized long getPosition() + throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + return (long)m_nCurPos; + } + + // ---------------------------------------------------------- + public synchronized long getLength() + throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException + { + return (long)m_nCurSize; + } +}; + diff --git a/package/qa/storages/RegressionTest_114358.java b/package/qa/storages/RegressionTest_114358.java new file mode 100644 index 000000000000..51d3ecb4a8b4 --- /dev/null +++ b/package/qa/storages/RegressionTest_114358.java @@ -0,0 +1,190 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_114358 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_114358( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_114358: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // create a new storage based on the stream and change the substream + // as described in the bug description + // ================================================ + + byte pBytes2[] = { 2, 2 }; + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the substream, set new "MediaType" and "Compressed" properties to it, truncate and write new contents + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType4", true, pBytes2 ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // create a new readonly storage based on the stream and check the contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + // the MediaType and the contents must be up to date + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream1", "MediaType4", true, pBytes2 ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_125919.java b/package/qa/storages/RegressionTest_125919.java new file mode 100644 index 000000000000..0a13fc63758c --- /dev/null +++ b/package/qa/storages/RegressionTest_125919.java @@ -0,0 +1,134 @@ +package complex.storages; + +import java.lang.Integer; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; +import complex.storages.BorderedStream; + +public class RegressionTest_125919 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + int nMinTestLen = 0; + int nMaxTestLen = 60000; + + public RegressionTest_125919( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_125919: " ); + } + + public boolean test() + { + try + { + byte[] pBytes0 = new byte[0]; + byte[] pBytes18 = new byte[18000]; + byte[] pBytes36 = new byte[36000]; + + for ( int nInitInd = 0; nInitInd < 36000; nInitInd++ ) + { + pBytes36[nInitInd] = ( new Integer( nInitInd >> ( ( nInitInd % 2 ) * 8 ) ) ).byteValue(); + if ( nInitInd < 18000 ) + pBytes18[nInitInd] = ( new Integer( 256 - pBytes36[nInitInd] ) ).byteValue(); + } + + System.out.println( "This test can take up to some hours. The file size currently is about 50000." ); + System.out.println( "Progress: " ); + for ( int nAvailableBytes = nMinTestLen; nAvailableBytes < nMaxTestLen; nAvailableBytes++ ) + { + Object oBStream = new BorderedStream( nAvailableBytes ); + XStream xBorderedStream = (XStream)UnoRuntime.queryInterface( XStream.class, oBStream ); + if ( xBorderedStream == null ) + { + m_aTestHelper.Error( "Can't create bordered stream!" ); + return false; + } + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xBorderedStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + XTransactedObject xTransact = (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xTempStorage ); + if ( xTransact == null ) + { + m_aTestHelper.Error( "This test is designed for storages in transacted mode!" ); + return false; + } + + + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream" + 0, "MediaType1", true, pBytes0 ) ) + return false; + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream" + 18, "MediaType2", true, pBytes18 ) ) + return false; + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream" + 36, "MediaType3", true, pBytes36 ) ) + return false; + + if ( nAvailableBytes > 0 && nAvailableBytes % 100 == 0 ) + System.out.println( " " + nAvailableBytes ); + + if ( nAvailableBytes > 0 && nAvailableBytes % 2 == 1 ) + System.out.print( "#" ); + + try + { + xTransact.commit(); + + System.out.println( "" ); + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // SUCCESS + return true; + } + catch( UseBackupException aExc ) + { + // when there is not enough place in the target location and the target file is empty + // the direct writing will fail and must throw this exception with empty URL + if ( aExc.TemporaryFileURL.length() != 0 ) + return false; + } + catch( Exception e ) + { + System.out.println( "" ); + m_aTestHelper.Error( "Unexpected exception: " + e + "\nnAvailableBytes = " + nAvailableBytes ); + return false; + } + } + + return false; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i26398.java b/package/qa/storages/RegressionTest_i26398.java new file mode 100644 index 000000000000..9116a7d9bafa --- /dev/null +++ b/package/qa/storages/RegressionTest_i26398.java @@ -0,0 +1,146 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i26398 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i26398( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i26398: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + + // ================================================ + // commit the substorage, dispose it, reopen readonly + // and dispose the reopened substorage + // ================================================ + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // open a new substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // ================================================ + // reopen the substorage in readwrite mode and check contents + // ================================================ + + // open a new substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType3", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType2", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // the root storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i27773.java b/package/qa/storages/RegressionTest_i27773.java new file mode 100644 index 000000000000..4e627a816167 --- /dev/null +++ b/package/qa/storages/RegressionTest_i27773.java @@ -0,0 +1,299 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; +import com.sun.star.beans.XPropertySet; +import com.sun.star.uno.AnyConverter; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +/////////////////////////////////// +// Tests also fix for i51352 +/////////////////////////////////// + +public class RegressionTest_i27773 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i27773( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i27773: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + if ( true ) + { + // for debugging proposes + + XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xTempFileStream ); + if ( xPropSet != null ) + { + try + { + String sTempURL = AnyConverter.toString( xPropSet.getPropertyValue( "Uri" ) ); + // m_aTestHelper.Message( "URL: " + sTempURL ); + xPropSet.setPropertyValue( "RemoveFile", new Boolean( false ) ); + } + catch ( Exception e ) + { + } + } + } + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open an empty substorage + XStorage xEmptySubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "EmptySubStorage1", + ElementModes.WRITE ); + if ( xEmptySubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open an empty substorage + XStorage xEmptySubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "EmptySubSubStorage1", + ElementModes.WRITE ); + if ( xEmptySubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xEmptySubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xEmptySubSubStorage, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + + // make a copy of substorage + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempStorage, "SubStorage1_copy" ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "EmptySubStorage1", xTempStorage, "EmptySubStorage1_copy" ) ) + return false; + + // ================================================ + // copy all the changed and noncommited substorages + // and dispose them + // ================================================ + + if ( !m_aTestHelper.commitStorage( xEmptySubSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xEmptySubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorages + + if ( !m_aTestHelper.disposeStorage( xEmptySubSubStorage ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xEmptySubStorage ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the storage in readonly mode an check contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open original substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open copy of the original substorage + XStorage xTempSubStorage_copy = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1_copy", + ElementModes.READ ); + if ( xTempSubStorage_copy == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open empty substorage + xEmptySubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "EmptySubStorage1", + ElementModes.READ ); + if ( xEmptySubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open copy of empty substorage + XStorage xEmptySubStorage_copy = m_aTestHelper.openSubStorage( xTempStorage, + "EmptySubStorage1_copy", + ElementModes.READ ); + if ( xEmptySubStorage_copy == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open an empty substorage of the substorage + xEmptySubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "EmptySubSubStorage1", + ElementModes.READ ); + if ( xEmptySubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open an empty substorage of the substorage copy + XStorage xEmptySubSubStorage_inCopy = m_aTestHelper.openSubStorage( xTempSubStorage_copy, + "EmptySubSubStorage1", + ElementModes.READ ); + if ( xEmptySubSubStorage_inCopy == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + + // check contents + + if ( !m_aTestHelper.checkStorageProperties( xEmptySubSubStorage, "MediaType5", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xEmptySubSubStorage_inCopy, "MediaType5", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage_copy, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xEmptySubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xEmptySubStorage_copy, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage_copy, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // the root storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i29169.java b/package/qa/storages/RegressionTest_i29169.java new file mode 100644 index 000000000000..580ee510caf8 --- /dev/null +++ b/package/qa/storages/RegressionTest_i29169.java @@ -0,0 +1,369 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i29169 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i29169( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i29169: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // open a new substorage in the existing substorage + XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType2", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType5", + true, + ElementModes.WRITE ) ) + return false; + + // ================================================ + // commit the storages, and check the renaming in all stages + // ================================================ + + // rename the storage before it is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage1", "SubSubStorage2" ) ) + return false; + + // rename the stream + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream1", "SubStream2" ) ) + return false; + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // rename the storage after it is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage2", "SubSubStorage3" ) ) + return false; + + // rename the stream one more time + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream2", "SubStream3" ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // rename the storage after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage3", "SubSubStorage4" ) ) + return false; + + // rename the stream after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream3", "SubStream4" ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // rename the storage after the package is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage4", "SubSubStorage5" ) ) + return false; + + // rename the stream after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream4", "SubStream5" ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // create a new storage based on the stream and check the substreams and substorages + // ================================================ + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorage + xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage5", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // check the storages and streams + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage, "MediaType3", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType4", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType5", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream5", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage, "SubSubStream1", "MediaType2", true, pBytes1 ) ) + return false; + + // ================================================ + // rename the reopened storages and streams + // ================================================ + + // rename the storage before it is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage5", "SubSubStorage6" ) ) + return false; + + // rename the stream + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream5", "SubStream6" ) ) + return false; + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // rename the storage after it is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage6", "SubSubStorage7" ) ) + return false; + + // rename the stream one more time + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream6", "SubStream7" ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // rename the storage after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage7", "SubSubStorage8" ) ) + return false; + + // rename the stream after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream7", "SubStream8" ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // rename the storage after the package is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage8", "SubSubStorage9" ) ) + return false; + + // rename the stream after it`s parent is commited + if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubStream8", "SubStream9" ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + + // ================================================ + // create a new readonly storage based on the stream and check the contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorage + xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage9", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // check the storages and streams + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType5", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream9", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage, "SubSubStream1", "MediaType2", true, pBytes1 ) ) + return false; + + // the storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i29321.java b/package/qa/storages/RegressionTest_i29321.java new file mode 100644 index 000000000000..740f48ce59a3 --- /dev/null +++ b/package/qa/storages/RegressionTest_i29321.java @@ -0,0 +1,170 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i29321 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i29321( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i29321: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substorage + XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xTempSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "Stream1", "MediaType1", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType2", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType3", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType4", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage, + "MediaType6", + false, + ElementModes.WRITE ) ) + return false; + + // ================================================ + // commit the storages twice to test the bug scenario + // ================================================ + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // check the storages and streams without closing + // ================================================ + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage, "MediaType6", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType5", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType4", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage, "SubSubStream1", "MediaType3", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream1", "MediaType2", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempStorage, "Stream1", "MediaType1", true, pBytes1 ) ) + return false; + + // the root storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i30400.java b/package/qa/storages/RegressionTest_i30400.java new file mode 100644 index 000000000000..5f82a7beb39e --- /dev/null +++ b/package/qa/storages/RegressionTest_i30400.java @@ -0,0 +1,435 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i30400 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i30400( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i30400: " ); + } + + public boolean test() + { + try + { + // ================================================ + // create a temporary stream and a storage based on it + // fill the storage with the data that will be used for testing + // ================================================ + + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + String pPass1 = "1, 2, 3, 4, 5"; + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "Stream1", "MediaType1", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "EncrStream1", "MediaType2", true, pBytes1, pPass1 ) ) + return false; + + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType3", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubEncrStream1", "MediaType4", true, pBytes1, pPass1 ) ) + return false; + + // open a new substorage in the existing substorage + XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType5", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage, + "MediaType6", + false, + ElementModes.WRITE ) ) + return false; + + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType7", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType8", + true, + ElementModes.WRITE ) ) + return false; + + // ================================================ + // check the copying with renaming + // ================================================ + + if ( !TestCopyWithRenaming( xTempStorage, xTempSubStorage, xTempSubSubStorage ) ) + return false; + + // ================================================ + // commit the storages + // ================================================ + + // commit lowlevel substorage + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the target storage readonly, and check the copying with renaming + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorages + + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorages + + xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.READ ); + if ( xTempSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // test the copying with renaming + if ( !TestCopyWithRenaming( xTempStorage, xTempSubStorage, xTempSubSubStorage ) ) + return false; + + + // the storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + + + public boolean TestCopyWithRenaming( XStorage xTempStorage, XStorage xTempSubStorage, XStorage xTempSubSubStorage ) + throws com.sun.star.uno.Exception + { + // ================================================ + // create a second temporary stream and copy all the staff there + // with renaming, check the success + // ================================================ + + XStream xTempFileStream2 = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream2 == null ) + return false; + + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream2; + pArgs[1] = new Integer( ElementModes.WRITE ); + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + String pPass1 = "1, 2, 3, 4, 5"; + + Object oTempStorage2 = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage2 = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage2 ); + if ( xTempStorage2 == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage2, + "SubStorage1_target", + ElementModes.WRITE ); + if ( xTempSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substorage in the existing substorage + XStorage xTempSubSubStorage2 = m_aTestHelper.openSubStorage( xTempSubStorage2, + "SubSubStorage1_target", + ElementModes.WRITE ); + if ( xTempSubSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // make a copy with renaming on lowerest level + if ( !m_aTestHelper.copyElementTo( xTempSubSubStorage, "SubSubStream1", xTempSubSubStorage2, "SubSubStream1_renamed" ) ) + return false; + + // make a copy with renaming on the next level + + if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubStream1", xTempSubStorage2, "SubStream1_renamed" ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubEncrStream1", xTempSubStorage2, "SubEncrStream1_renamed" ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempSubStorage, "SubSubStorage1", xTempSubStorage2, "SubSubStorage1_renamed" ) ) + return false; + + // make a copy with renaming of subelements of the root storage + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "Stream1", xTempStorage2, "Stream1_renamed" ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "EncrStream1", xTempStorage2, "EncrStream1_renamed" ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempStorage2, "SubStorage1_renamed" ) ) + return false; + + // ================================================ + // commit the storages, and check the renaming in all stages + // ================================================ + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage2 ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempSubStorage2 ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage2 ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage2 ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage2 ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage2 ) ) + return false; + + // ================================================ + // reopen the target storage readonly, and check the contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage2 = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage2 = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage2 ); + if ( xTempStorage2 == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorages + + XStorage xTempSubStorage2_target = m_aTestHelper.openSubStorage( xTempStorage2, + "SubStorage1_target", + ElementModes.READ ); + if ( xTempSubStorage2_target == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + XStorage xTempSubStorage2_renamed = m_aTestHelper.openSubStorage( xTempStorage2, + "SubStorage1_renamed", + ElementModes.READ ); + if ( xTempSubStorage2_renamed == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorages + + XStorage xTempSubSubStorage2_inRenamed = m_aTestHelper.openSubStorage( xTempSubStorage2_renamed, + "SubSubStorage1", + ElementModes.READ ); + if ( xTempSubSubStorage2_inRenamed == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + XStorage xTempSubSubStorage2_renamed = m_aTestHelper.openSubStorage( xTempSubStorage2_target, + "SubSubStorage1_renamed", + ElementModes.READ ); + if ( xTempSubSubStorage2_renamed == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + XStorage xTempSubSubStorage2_target = m_aTestHelper.openSubStorage( xTempSubStorage2_target, + "SubSubStorage1_target", + ElementModes.READ ); + if ( xTempSubSubStorage2_target == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // check the storages + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage2_inRenamed, "MediaType6", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage2_renamed, "MediaType6", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage2_renamed, "MediaType7", false, ElementModes.READ ) ) + return false; + + + // check the streams + + + // sub sub level + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_inRenamed, "SubSubStream1", "MediaType5", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_renamed, "SubSubStream1", "MediaType5", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage2_target, "SubSubStream1_renamed", "MediaType5", true, pBytes1 ) ) + return false; + + // sub level + + if ( !m_aTestHelper.checkStream( xTempSubStorage2_renamed, "SubStream1", "MediaType3", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xTempSubStorage2_renamed, "SubEncrStream1", "MediaType4", pBytes1, pPass1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage2_target, "SubStream1_renamed", "MediaType3", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xTempSubStorage2_target, "SubEncrStream1_renamed", "MediaType4", pBytes1, pPass1 ) ) + return false; + + // root storage level + + if ( !m_aTestHelper.checkStream( xTempStorage2, "Stream1_renamed", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xTempStorage2, "EncrStream1_renamed", "MediaType2", pBytes1, pPass1 ) ) + return false; + + // the storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } +} + diff --git a/package/qa/storages/RegressionTest_i30677.java b/package/qa/storages/RegressionTest_i30677.java new file mode 100644 index 000000000000..740c9e319313 --- /dev/null +++ b/package/qa/storages/RegressionTest_i30677.java @@ -0,0 +1,263 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i30677 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i30677( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i30677: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new subsubstorage + XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xTempSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // ================================================ + // commit the storages + // ================================================ + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the storage and rewrite the stream + // ================================================ + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorages + + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorages + + xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xTempSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType1", true, pBytes2 ) ) + return false; + + // ================================================ + // commit the storages + // ================================================ + + // commit lowlevel substorage first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit substorage to let the renaming take place + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // ================================================ + // dispose the storages + // ================================================ + + // dispose lowerest substorage + if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the storages and check the contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorages + + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open the lowlevel substorages + + xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.READ ); + if ( xTempSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempSubSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubSubStorage, "SubSubStream1", "MediaType1", true, pBytes2 ) ) + return false; + + // the root storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i35095.java b/package/qa/storages/RegressionTest_i35095.java new file mode 100644 index 000000000000..d98ec800a5a6 --- /dev/null +++ b/package/qa/storages/RegressionTest_i35095.java @@ -0,0 +1,166 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i35095 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i35095( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i35095: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBytes[] = new byte[36000]; + for ( int nInd = 0; nInd < 36000; nInd++ ) + pBytes[nInd] = (byte)( nInd % 128 ); + + String sPass = "12345"; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes, sPass ) ) + return false; + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubStream2", "MediaType2", false, pBytes, sPass ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // now check all the written information + // and the raw stream contents + // ================================================ + + // close the output part of the temporary stream + // the output part must present since we already wrote to the stream + if ( !m_aTestHelper.closeOutput( xTempFileStream ) ) + return false; + + XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream ); + if ( xTempInStream == null ) + return false; + + // open input stream + // since no mode is provided the result storage must be opened readonly + Object pOneArg[] = new Object[1]; + pOneArg[0] = (Object) xTempInStream; + + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.compareRawMethodsOnEncrStream( xResultStorage, "SubStream1" ) ) + return false; + + if ( !m_aTestHelper.compareRawMethodsOnEncrStream( xResultSubStorage, "SubStream2" ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/RegressionTest_i46848.java b/package/qa/storages/RegressionTest_i46848.java new file mode 100644 index 000000000000..438626e9a7ba --- /dev/null +++ b/package/qa/storages/RegressionTest_i46848.java @@ -0,0 +1,191 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i46848 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i46848( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i46848: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // create a new storage based on the stream and change the mediatype of the substorage + // as described in the bug description + // ================================================ + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "ChangedMediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // dispose the temporary storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // create a new readonly storage based on the stream and check the contents + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open the substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.READ ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xTempSubStorage, "ChangedMediaType3", false, ElementModes.READ ) ) + return false; + + // the MediaType and the contents must be up to date + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i49755.java b/package/qa/storages/RegressionTest_i49755.java new file mode 100644 index 000000000000..7d3ee6c01cac --- /dev/null +++ b/package/qa/storages/RegressionTest_i49755.java @@ -0,0 +1,272 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i49755 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i49755( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i49755: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType1", + true, + ElementModes.WRITE ) ) + return false; + + + byte pBytes[] = new byte[36000]; + for ( int nInd = 0; nInd < 36000; nInd++ ) + pBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType2", + false, + ElementModes.WRITE ) ) + return false; + + // open a new substorage + XStorage xTempSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubStorage2", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubStream1", "MediaType4", true, pBytes ) ) + return false; + + // open a new substorage + XStorage xTempSubStorage1 = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage3", + ElementModes.WRITE ); + if ( xTempSubStorage1 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage1, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "SubStream2", "MediaType4", false, pBytes ) ) + return false; + + + // commit substorages first + if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempSubStorage1 ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // now change the contents of the second substorage + // without changing of the contents of the first substorage + // ================================================ + + Object oStep2TempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xStep2TempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStep2TempStorage ); + if ( xStep2TempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + XStorage xStep2TempSubStorage1 = m_aTestHelper.openSubStorage( xStep2TempStorage, + "SubStorage3", + ElementModes.WRITE ); + if ( xStep2TempSubStorage1 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xStep2TempSubStorage1, "SubStream2", "MediaType4", false, pBytes ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xStep2TempSubStorage1 ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xStep2TempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xStep2TempStorage ) ) + return false; + + + // ================================================ + // now check all the written information + // and the raw stream contents + // ================================================ + + // close the output part of the temporary stream + // the output part must present since we already wrote to the stream + if ( !m_aTestHelper.closeOutput( xTempFileStream ) ) + return false; + + XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream ); + if ( xTempInStream == null ) + return false; + + // open input stream + // since no mode is provided the result storage must be opened readonly + Object pOneArg[] = new Object[1]; + pOneArg[0] = (Object) xTempInStream; + + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType1", true, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType2", false, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResultSubSubStorage = m_aTestHelper.openSubStorage( xResultSubStorage, + "SubStorage2", + ElementModes.READ ); + if ( xResultSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubSubStorage, "SubStream1", "MediaType4", true, pBytes ) ) + return false; + + + + XStorage xResultSubStorage1 = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage3", + ElementModes.READ ); + if ( xResultSubStorage1 == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage1, "MediaType5", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage1, "SubStream2", "MediaType4", false, pBytes ) ) + return false; + + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/RegressionTest_i55821.java b/package/qa/storages/RegressionTest_i55821.java new file mode 100644 index 000000000000..0803816427d6 --- /dev/null +++ b/package/qa/storages/RegressionTest_i55821.java @@ -0,0 +1,111 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i55821 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i55821( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i55821: " ); + } + + public boolean test() + { + try + { + // ================================================ + // create a temporary stream and a storage based on it + // fill the storage with the data that will be used for testing + // ================================================ + + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + String sPass = "12345"; + byte pBytes[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will not be encrypted + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", false, pBytes, sPass ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream2", "MediaType2", false, pBytes, sPass ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the target storage readonly, and check contents + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "SubStream1", "MediaType1", pBytes, sPass ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "SubStream2", "MediaType2", pBytes, sPass ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i59886.java b/package/qa/storages/RegressionTest_i59886.java new file mode 100644 index 000000000000..471149823c33 --- /dev/null +++ b/package/qa/storages/RegressionTest_i59886.java @@ -0,0 +1,243 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i59886 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i59886( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i59886: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBytes[] = new byte[36000]; + for ( int nInd = 0; nInd < 36000; nInd++ ) + pBytes[nInd] = (byte)( nInd % 128 ); + + String sPass = "12345"; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes, sPass ) ) + return false; + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubStream2", "MediaType2", false, pBytes, sPass ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // now reopen the storage, set the common storage key + // and copy the storage + // ================================================ + + Object oStep2TempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xStep2TempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStep2TempStorage ); + if ( xStep2TempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + + XStorage xStep2TempSubStorage = m_aTestHelper.openSubStorage( xStep2TempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xStep2TempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // set the common storage password + XEncryptionProtectedSource xEncr = (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xStep2TempStorage ); + if ( xEncr == null ) + { + m_aTestHelper.Error( "The storage does not support encryption access!" ); + return false; + } + try + { + xEncr.setEncryptionPassword( sPass ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can not set the common storage password!" ); + return false; + } + + // open the stream for writing and read them so that the cache is created, but do not change + byte pDummyData[][] = new byte[1][3]; + XStream xTempStream1 = m_aTestHelper.OpenStream( xStep2TempStorage, "SubStream1", ElementModes.WRITE ); + XStream xTempStream2 = m_aTestHelper.OpenStream( xStep2TempSubStorage, "SubStream2", ElementModes.WRITE ); + if ( xTempStream1 == null || xTempStream2 == null ) + return false; + + XInputStream xTempInStream1 = xTempStream1.getInputStream(); + XInputStream xTempInStream2 = xTempStream2.getInputStream(); + if ( xTempInStream1 == null || xTempInStream2 == null ) + { + m_aTestHelper.Error( "No input stream is available!" ); + return false; + } + + xTempInStream1.readBytes( pDummyData, 3 ); + xTempInStream2.readBytes( pDummyData, 3 ); + + + // create temporary storage, it will be checked later + Object oTargetStorage = m_xStorageFactory.createInstance(); + XStorage xTargetStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTargetStorage ); + if ( xTargetStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // copy the current storage to the target + try + { + xStep2TempStorage.copyToStorage( xTargetStorage ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can not copy the storage with common storage password!" ); + return false; + } + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xStep2TempStorage ) ) + return false; + + // ================================================ + // now check all the information in the copy + // ================================================ + + if ( !m_aTestHelper.checkStorageProperties( xTargetStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + // open existing substorage + XStorage xTargetSubStorage = m_aTestHelper.openSubStorage( xTargetStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTargetSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTargetSubStorage, "MediaType4", false, ElementModes.WRITE ) ) + return false; + + // set the common storage password + XEncryptionProtectedSource xTargetEncr = (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xTargetStorage ); + if ( xTargetEncr == null ) + { + m_aTestHelper.Error( "The storage does not support encryption access!" ); + return false; + } + try + { + xTargetEncr.setEncryptionPassword( sPass ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can not set the common storage password!" ); + return false; + } + + // check the streams + if ( !m_aTestHelper.checkStream( xTargetStorage, "SubStream1", "MediaType1", true, pBytes ) ) + return false; + if ( !m_aTestHelper.checkStream( xTargetSubStorage, "SubStream2", "MediaType2", true, pBytes ) ) + return false; + + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTargetStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i61909.java b/package/qa/storages/RegressionTest_i61909.java new file mode 100644 index 000000000000..5f5c1572d79d --- /dev/null +++ b/package/qa/storages/RegressionTest_i61909.java @@ -0,0 +1,167 @@ +package complex.storages; + +import java.net.URI; +import java.io.File; +import java.io.FileInputStream; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipEntry; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i61909 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i61909( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i61909: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBytes[] = new byte[36000]; + for ( int nInd = 0; nInd < 36000; nInd++ ) + pBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes ) ) + return false; + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream2", "MediaType2", true, pBytes ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // now reopen the storage, and insert a new stream + // ================================================ + + Object oStep2TempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xStep2TempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStep2TempStorage ); + if ( xStep2TempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xStep2TempStorage, "SubStream3", "MediaType5", true, pBytes ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xStep2TempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xStep2TempStorage ) ) + return false; + + // ================================================ + // now access the stream using ZipInputStream + // ================================================ + + URI aUri = new URI( sTempFileURL ); + File aFile = new File( aUri ); + FileInputStream aFileStream = new FileInputStream( aFile ); + ZipInputStream aZipStream = new ZipInputStream( aFileStream ); + + ZipEntry aEntry; + int nNumber = 0; + m_aTestHelper.Message( "Available entries:" ); + while ( ( aEntry = aZipStream.getNextEntry() ) != null ) + { + nNumber++; + m_aTestHelper.Message( aEntry.getName() ); + } + + if ( nNumber != 6 ) + { + m_aTestHelper.Error( "Wrong number of entries: " + nNumber + ", Expected: 6" ); + return false; + } + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/RegressionTest_i84234.java b/package/qa/storages/RegressionTest_i84234.java new file mode 100644 index 000000000000..16150690d882 --- /dev/null +++ b/package/qa/storages/RegressionTest_i84234.java @@ -0,0 +1,134 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class RegressionTest_i84234 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public RegressionTest_i84234( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "RegressionTest_i84234: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream1", "text/xml", false, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream2", "text/xml", false, pBytes1 ) ) + return false; + + + // ================================================ + // commit the storages and dispose them + // ================================================ + + // commit substorage + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // commit storage + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose storage + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // reopen the storages in readwrite mode and check Compressed flag + // ================================================ + + oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStream( xTempStorage, "SubStream1", "text/xml", false, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xTempSubStorage, "SubStream2", "text/xml", false, pBytes1 ) ) + return false; + + // the root storage is based on the temporary stream so it can be left undisposed, since it does not lock + // any resource, later the garbage collector will release the object and it must die by refcount + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/StorageTest.java b/package/qa/storages/StorageTest.java new file mode 100644 index 000000000000..4691564c23a0 --- /dev/null +++ b/package/qa/storages/StorageTest.java @@ -0,0 +1,7 @@ +package complex.storages; + +public interface StorageTest +{ + boolean test(); +} + diff --git a/package/qa/storages/StorageUnitTest.java b/package/qa/storages/StorageUnitTest.java new file mode 100644 index 000000000000..e5010d86c735 --- /dev/null +++ b/package/qa/storages/StorageUnitTest.java @@ -0,0 +1,326 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +package complex.storages; + +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XMultiComponentFactory; +import com.sun.star.connection.XConnector; +import com.sun.star.connection.XConnection; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.uno.XNamingService; +import com.sun.star.uno.XComponentContext; + +import com.sun.star.container.*; +import com.sun.star.beans.*; +import com.sun.star.lang.*; + +import complexlib.ComplexTestCase; + +import complex.storages.*; + +import util.utils; +import java.util.*; +import java.io.*; + +/* This unit test for storage objects is designed to + * test most important statements from storage service + * specification. + * + * Regression tests are added to extend the tested + * functionalities. + */ +public class StorageUnitTest extends ComplexTestCase +{ + private XMultiServiceFactory m_xMSF = null; + private XSingleServiceFactory m_xStorageFactory = null; + + public String[] getTestMethodNames() + { + return new String[] { + "ExecuteTest01", + "ExecuteTest02", + "ExecuteTest03", + "ExecuteTest04", + "ExecuteTest05", + "ExecuteTest06", + "ExecuteTest07", + "ExecuteTest08", + "ExecuteTest09", + "ExecuteTest10", + "ExecuteTest11", + "ExecuteTest12", + "ExecuteTest13", + "ExecuteTest14", + "ExecuteTest15", + "ExecuteTest16", + "ExecuteTest17", + "ExecuteTest18", + "ExecuteRegressionTest_114358", + "ExecuteRegressionTest_i29169", + "ExecuteRegressionTest_i30400", + "ExecuteRegressionTest_i29321", + "ExecuteRegressionTest_i30677", + "ExecuteRegressionTest_i27773", + "ExecuteRegressionTest_i46848", + "ExecuteRegressionTest_i55821", + "ExecuteRegressionTest_i35095", + "ExecuteRegressionTest_i49755", + "ExecuteRegressionTest_i59886", + "ExecuteRegressionTest_i61909", + "ExecuteRegressionTest_i84234", + "ExecuteRegressionTest_125919" + }; + } + + public String getTestObjectName() + { + return "StorageUnitTest"; + } + + public void before() + { + m_xMSF = (XMultiServiceFactory)param.getMSF(); + if ( m_xMSF == null ) + { + failed( "Can't create service factory!" ); + return; + } + + try { + Object oStorageFactory = m_xMSF.createInstance( "com.sun.star.embed.StorageFactory" ); + m_xStorageFactory = (XSingleServiceFactory)UnoRuntime.queryInterface( XSingleServiceFactory.class, + oStorageFactory ); + } + catch( Exception e ) + { + failed( "Can't create storage factory!" ); + return; + } + + if ( m_xStorageFactory == null ) + { + failed( "Can't create service factory!" ); + return; + } + } + + public void ExecuteTest01() + { + StorageTest aTest = new Test01( m_xMSF, m_xStorageFactory, log ); + assure( "Test01 failed!", aTest.test() ); + } + + public void ExecuteTest02() + { + StorageTest aTest = new Test02( m_xMSF, m_xStorageFactory, log ); + assure( "Test02 failed!", aTest.test() ); + } + + public void ExecuteTest03() + { + StorageTest aTest = new Test03( m_xMSF, m_xStorageFactory, log ); + assure( "Test03 failed!", aTest.test() ); + } + + public void ExecuteTest04() + { + StorageTest aTest = new Test04( m_xMSF, m_xStorageFactory, log ); + assure( "Test04 failed!", aTest.test() ); + } + + public void ExecuteTest05() + { + StorageTest aTest = new Test05( m_xMSF, m_xStorageFactory, log ); + assure( "Test05 failed!", aTest.test() ); + } + + public void ExecuteTest06() + { + StorageTest aTest = new Test06( m_xMSF, m_xStorageFactory, log ); + assure( "Test06 failed!", aTest.test() ); + } + + public void ExecuteTest07() + { + StorageTest aTest = new Test07( m_xMSF, m_xStorageFactory, log ); + assure( "Test07 failed!", aTest.test() ); + } + + public void ExecuteTest08() + { + StorageTest aTest = new Test08( m_xMSF, m_xStorageFactory, log ); + assure( "Test08 failed!", aTest.test() ); + } + + public void ExecuteTest09() + { + StorageTest aTest = new Test09( m_xMSF, m_xStorageFactory, log ); + assure( "Test09 failed!", aTest.test() ); + } + + public void ExecuteTest10() + { + StorageTest aTest = new Test10( m_xMSF, m_xStorageFactory, log ); + assure( "Test10 failed!", aTest.test() ); + } + + public void ExecuteTest11() + { + StorageTest aTest = new Test11( m_xMSF, m_xStorageFactory, log ); + assure( "Test11 failed!", aTest.test() ); + } + + public void ExecuteTest12() + { + StorageTest aTest = new Test12( m_xMSF, m_xStorageFactory, log ); + assure( "Test12 failed!", aTest.test() ); + } + + public void ExecuteTest13() + { + StorageTest aTest = new Test13( m_xMSF, m_xStorageFactory, log ); + assure( "Test13 failed!", aTest.test() ); + } + + public void ExecuteTest14() + { + StorageTest aTest = new Test14( m_xMSF, m_xStorageFactory, log ); + assure( "Test14 failed!", aTest.test() ); + } + + public void ExecuteTest15() + { + StorageTest aTest = new Test15( m_xMSF, m_xStorageFactory, log ); + assure( "Test15 failed!", aTest.test() ); + } + + public void ExecuteTest16() + { + StorageTest aTest = new Test16( m_xMSF, m_xStorageFactory, log ); + assure( "Test16 failed!", aTest.test() ); + } + + public void ExecuteTest17() + { + StorageTest aTest = new Test17( m_xMSF, m_xStorageFactory, log ); + assure( "Test17 failed!", aTest.test() ); + } + + public void ExecuteTest18() + { + StorageTest aTest = new Test18( m_xMSF, m_xStorageFactory, log ); + assure( "Test18 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_114358() + { + StorageTest aTest = new RegressionTest_114358( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_114358 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i29169() + { + StorageTest aTest = new RegressionTest_i29169( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i29169 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i30400() + { + StorageTest aTest = new RegressionTest_i30400( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i30400 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i29321() + { + StorageTest aTest = new RegressionTest_i29321( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i29321 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i30677() + { + StorageTest aTest = new RegressionTest_i30677( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i30677 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i27773() + { + StorageTest aTest = new RegressionTest_i27773( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i27773 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i46848() + { + StorageTest aTest = new RegressionTest_i46848( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i46848 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i55821() + { + StorageTest aTest = new RegressionTest_i55821( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i55821 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i35095() + { + StorageTest aTest = new RegressionTest_i35095( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i35095 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i49755() + { + StorageTest aTest = new RegressionTest_i49755( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i49755 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i59886() + { + StorageTest aTest = new RegressionTest_i59886( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i59886 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i61909() + { + StorageTest aTest = new RegressionTest_i61909( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i61909 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_i84234() + { + StorageTest aTest = new RegressionTest_i84234( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_i84234 failed!", aTest.test() ); + } + + public void ExecuteRegressionTest_125919() + { + StorageTest aTest = new RegressionTest_125919( m_xMSF, m_xStorageFactory, log ); + assure( "RegressionTest_125919 failed!", aTest.test() ); + } +} + diff --git a/package/qa/storages/Test01.java b/package/qa/storages/Test01.java new file mode 100644 index 000000000000..a793a2fd5809 --- /dev/null +++ b/package/qa/storages/Test01.java @@ -0,0 +1,177 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test01 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test01( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test01: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.WRITE ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test02.java b/package/qa/storages/Test02.java new file mode 100644 index 000000000000..668efbe6a509 --- /dev/null +++ b/package/qa/storages/Test02.java @@ -0,0 +1,163 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test02 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test02( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test02: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + + // ================================================ + // now check all the written information + // ================================================ + + // close the output part of the temporary stream + // the output part must present since we already wrote to the stream + if ( !m_aTestHelper.closeOutput( xTempFileStream ) ) + return false; + + XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream ); + if ( xTempInStream == null ) + return false; + + + // open input stream + // since no mode is provided the result storage must be opened readonly + Object pOneArg[] = new Object[1]; + pOneArg[0] = (Object) xTempInStream; + + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test03.java b/package/qa/storages/Test03.java new file mode 100644 index 000000000000..353cd4df8d14 --- /dev/null +++ b/package/qa/storages/Test03.java @@ -0,0 +1,231 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; +import com.sun.star.container.XNameAccess; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test03 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test03( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test03: " ); + } + + public boolean test() + { + try + { + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // ================================================ + // check storage hyerarchy tree + // ================================================ + + // check that isStorageElement() and isStreamElement reacts to nonexisting object correctly + try { + xTempStorage.isStorageElement( "does not exist" ); + m_aTestHelper.Error( "Nonexisting element doesn't detected by isStorageElement() call!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + { + } + catch( Exception e ) + { + m_aTestHelper.Error( "Wrong exception is thrown by isStorageElement() call: " + e ); + return false; + } + + try { + xTempStorage.isStreamElement( "does not exist" ); + m_aTestHelper.Error( "Nonexisting element doesn't detected by isStreamElement() call!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + { + } + catch( Exception e ) + { + m_aTestHelper.Error( "Wrong exception is thrown by isStreamElement() call: " + e ); + return false; + } + + XNameAccess xRootNameAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xTempStorage ); + if ( xRootNameAccess == null ) + { + m_aTestHelper.Error( "Root storage doesn't support XNameAccess!" ); + return false; + } + + try { + if ( !xTempStorage.isStorageElement( "SubStorage1" ) || xTempStorage.isStreamElement( "SubStorage1" ) ) + { + m_aTestHelper.Error( "Child 'SubStorage1' can not be detected as storage!" ); + return false; + } + + if ( xTempStorage.isStorageElement( "SubStream1" ) || !xTempStorage.isStreamElement( "SubStream1" ) ) + { + m_aTestHelper.Error( "Child 'SubStream1' can not be detected as stream!" ); + return false; + } + } + catch( Exception e ) + { + m_aTestHelper.Error( "Child's type can not be detected, exception: " + e ); + return false; + } + + + // check that root storage contents are represented correctly + String sRootCont[] = xRootNameAccess.getElementNames(); + + if ( sRootCont.length != 3 ) + { + m_aTestHelper.Error( "Root storage contains wrong amount of children!" ); + return false; + } + + int nFlag = 0; + for ( int nInd = 0; nInd < sRootCont.length; nInd++ ) + { + if ( sRootCont[nInd].equals( "SubStorage1" ) ) + nFlag |= 1; + else if ( sRootCont[nInd].equals( "SubStream1" ) ) + nFlag |= 2; + else if ( sRootCont[nInd].equals( "BigSubStream1" ) ) + nFlag |= 4; + } + + if ( nFlag != 7 || !( xRootNameAccess.hasByName( "BigSubStream1" ) && xRootNameAccess.hasByName( "SubStream1" ) && xRootNameAccess.hasByName( "SubStorage1" ) ) ) + { + m_aTestHelper.Error( "Root storage contains wrong list of children!" ); + return false; + } + + // get storage through XNameAccess + XStorage xResultSubStorage = getStorageFromNameAccess( xRootNameAccess, "SubStorage1" ); + if ( xResultSubStorage == null ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType3", false, ElementModes.READ ) ) + return false; + + XNameAccess xChildAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xResultSubStorage ); + if ( xChildAccess == null ) + { + m_aTestHelper.Error( "Child storage doesn't support XNameAccess!" ); + return false; + } + + if ( !( xChildAccess.hasByName( "SubStream2" ) && xChildAccess.hasByName( "BigSubStream2" ) ) + || !xResultSubStorage.isStreamElement( "SubStream2" ) + || !xResultSubStorage.isStreamElement( "BigSubStream2" ) ) + { + m_aTestHelper.Error( "'SubStream2' can not be detected as child stream element of 'SubStorage1'!" ); + return false; + } + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + + public XStorage getStorageFromNameAccess( XNameAccess xAccess, String sName ) + { + try + { + Object oStorage = xAccess.getByName( sName ); + XStorage xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oStorage ); + + if ( xResult != null ) + return xResult; + else + m_aTestHelper.Error( "Can't retrieve substorage '" + sName + "' through XNameAccess!" ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't retrieve substorage '" + sName + "' through XNameAccess, exception: " + e ); + } + + return null; + } + +} + diff --git a/package/qa/storages/Test04.java b/package/qa/storages/Test04.java new file mode 100644 index 000000000000..81f770f8ff9a --- /dev/null +++ b/package/qa/storages/Test04.java @@ -0,0 +1,307 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; +import com.sun.star.lang.DisposedException; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.container.XNameAccess; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test04 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test04( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test04: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open substorages and create streams there + + // first substorage of the root storage + XStorage xTempSubStorage1 = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage1 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // second substorage of the root storage + XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage2", + ElementModes.WRITE ); + if ( xTempSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage1, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage2, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.copyElementTo( xTempStorage, "SubStorage1", xTempFileStorage ) ) + return false; + + // if storage is not commited before disposing all the changes will be lost + if ( !m_aTestHelper.commitStorage( xTempSubStorage2 ) ) + return false; + + // a storage must be disposed before moving/removing otherwise the access will be denied + if ( !m_aTestHelper.disposeStorage( xTempSubStorage2 ) ) + return false; + + if ( !m_aTestHelper.moveElementTo( xTempStorage, "SubStorage2", xTempFileStorage ) ) + return false; + + // SubStorage2 must be removed and disposed now + try + { + xTempSubStorage2.isStreamElement( "SubStream2" ); + m_aTestHelper.Error( "SubStorage2 must be disposed already!" ); + return false; + } + catch( com.sun.star.lang.DisposedException de ) + { + } + catch( Exception e ) + { + m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e ); + return false; + } + + if ( !m_aTestHelper.copyElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) ) + return false; + + if ( !m_aTestHelper.renameElement( xTempFileStorage, "SubStream1", "SubStream1_copy" ) ) + return false; + + if ( !m_aTestHelper.moveElementTo( xTempSubStorage1, "SubStream1", xTempFileStorage ) ) + return false; + + if ( !m_aTestHelper.copyElementTo( xTempSubStorage1, "BigSubStream1", xTempFileStorage ) ) + return false; + + if ( !m_aTestHelper.renameElement( xTempFileStorage, "BigSubStream1", "BigSubStream1_copy" ) ) + return false; + + if ( !m_aTestHelper.moveElementTo( xTempSubStorage1, "BigSubStream1", xTempFileStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.WRITE ); + Object oResStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResStorage ); + if ( xResStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + // open and check SubStorage1 + XStorage xResSubStorage1 = m_aTestHelper.openSubStorage( xResStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResSubStorage1 == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResSubStorage1, "MediaType4", false, ElementModes.READ ) ) + return false; + + + // open and check SubStorage2 + XStorage xResSubStorage2 = m_aTestHelper.openSubStorage( xResStorage, + "SubStorage2", + ElementModes.READ ); + if ( xResSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResSubStorage2, "MediaType5", false, ElementModes.READ ) ) + return false; + + + // check all the result streams + + if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResStorage, "SubStream1_copy", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResStorage, "BigSubStream1_copy", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubStorage2, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + // the storage must be disposed before removing + if ( !m_aTestHelper.disposeStorage( xResSubStorage2 ) ) + return false; + + // remove element and check that it was removed completelly + if ( !m_aTestHelper.removeElement( xResStorage, "SubStorage2" ) ) + return false; + + try + { + XNameAccess xResAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xResStorage ); + if ( xResAccess.hasByName( "SubStorage2" ) ) + m_aTestHelper.Error( "SubStorage2 must be removed already!" ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't get access to root storage, exception: " + e ); + return false; + } + + try + { + xResSubStorage2.isStreamElement( "SubStream2" ); + + m_aTestHelper.Error( "SubStorage2 must be disposed already!" ); + return false; + } + catch( com.sun.star.lang.DisposedException de ) + { + } + catch( Exception e ) + { + m_aTestHelper.Error( "Wrong exception in case of disposed storage, exception: " + e ); + return false; + } + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test05.java b/package/qa/storages/Test05.java new file mode 100644 index 000000000000..adf943c6ef12 --- /dev/null +++ b/package/qa/storages/Test05.java @@ -0,0 +1,299 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test05 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test05( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test05: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempFileStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substorage + XStorage xSubSubStorage = m_aTestHelper.openSubStorage( xTempSubStorage, + "SubSubStorage1", + ElementModes.WRITE ); + if ( xSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xSubSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xSubSubStorage, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + + // commit all the storages + if ( !m_aTestHelper.commitStorage( xSubSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // try to open an opened substorage, open call must fail + if ( !m_aTestHelper.cantOpenStorage( xTempFileStorage, "SubStorage1" ) ) + return false; + + + // reopen created streams + XStream xSubStream1 = m_aTestHelper.OpenStream( xSubSubStorage, + "SubStream1", + ElementModes.WRITE | ElementModes.NOCREATE ); + XStream xBigSubStream1 = m_aTestHelper.OpenStream( xSubSubStorage, + "BigSubStream1", + ElementModes.WRITE | ElementModes.NOCREATE ); + XStream xSubStream2 = m_aTestHelper.OpenStream( xSubSubStorage, + "SubStream2", + ElementModes.READ | ElementModes.NOCREATE ); + XStream xBigSubStream2 = m_aTestHelper.OpenStream( xSubSubStorage, + "BigSubStream2", + ElementModes.READ | ElementModes.NOCREATE ); + + if ( xSubStream1 == null || xBigSubStream1 == null || xSubStream2 == null || xBigSubStream2 == null ) + return false; + + // it should be possible to have more then one copy of stream for reading + XStream xSubStream2clone = m_aTestHelper.OpenStream( xSubSubStorage, + "SubStream2", + ElementModes.READ | ElementModes.NOCREATE ); + XStream xBigSubStream2clone = m_aTestHelper.OpenStream( xSubSubStorage, + "BigSubStream2", + ElementModes.READ | ElementModes.NOCREATE ); + if ( xSubStream2clone == null || xBigSubStream2clone == null ) + return false; + + + // so now the first streams can not be open neither for reading nor for writing + if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.WRITE ) + || !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream1", ElementModes.READ ) + || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream1", ElementModes.WRITE ) + || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream1", ElementModes.READ ) ) + return false; + + // the second streams can not be open for writing + if ( !m_aTestHelper.cantOpenStream( xSubSubStorage, "SubStream2", ElementModes.WRITE ) + || !m_aTestHelper.cantOpenStream( xSubSubStorage, "BigSubStream2", ElementModes.WRITE ) ) + return false; + + + // dispose xTestSubStorage, all the subtree must be disposed + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // check that subtree was disposed correctly + try + { + xSubSubStorage.isStreamElement( "SubStream1" ); + m_aTestHelper.Error( "Substorage was not disposed!" ); + return false; + } + catch ( com.sun.star.lang.DisposedException de ) + {} + catch ( Exception e ) + { + m_aTestHelper.Error( "Wrong exception is thrown by disposed storage: " + e ); + return false; + } + + try + { + xSubStream1.getInputStream(); + m_aTestHelper.Error( "Writeable substream was not disposed!" ); + return false; + } + catch ( com.sun.star.lang.DisposedException de ) + {} + catch ( Exception e ) + { + m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e ); + return false; + } + + try + { + xSubStream2.getInputStream(); + m_aTestHelper.Error( "Readonly substream was not disposed!" ); + return false; + } + catch ( com.sun.star.lang.DisposedException de ) + {} + catch ( Exception e ) + { + m_aTestHelper.Error( "Wrong exception is thrown by disposed stream: " + e ); + return false; + } + + + // dispose root storage + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + + // ================================================ + // now check all the written and copied information + // ================================================ + + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResSubSubStorage = m_aTestHelper.openSubStorage( xResSubStorage, + "SubSubStorage1", + ElementModes.READ ); + if ( xResSubSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage 'SubSubStorage'!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResSubSubStorage, "MediaType5", false, ElementModes.READ ) ) + return false; + + // check substreams + if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResSubSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test06.java b/package/qa/storages/Test06.java new file mode 100644 index 000000000000..ef42c66335a5 --- /dev/null +++ b/package/qa/storages/Test06.java @@ -0,0 +1,279 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.lang.IllegalArgumentException; +import com.sun.star.container.NoSuchElementException; +import com.sun.star.container.ElementExistException; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test06 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test06( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test06: " ); + } + + public boolean test() + { + try + { + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + try + { + xTempStorage.copyToStorage( null ); + m_aTestHelper.Error( "The method must throw an exception because of illegal parameter!" ); + return false; + } + catch( com.sun.star.lang.IllegalArgumentException iae ) + {} + catch( com.sun.star.uno.Exception ue ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion because of illegal parameter : " + e ); + return false; + } + + // open new substorages + XStorage xTempSubStorage1 = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + XStorage xTempSubStorage2 = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage2", + ElementModes.WRITE ); + if ( xTempSubStorage1 == null || xTempSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // in case stream is open for reading it must exist + try + { + xTempSubStorage1.openStreamElement( "NonExistingStream", ElementModes.READ ); + m_aTestHelper.Error( "The method must throw an exception in case of try to open nonexistent stream for reading!" ); + return false; + } + catch( com.sun.star.uno.Exception ue ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of try to open nonexistent stream for reading : " + e ); + return false; + } + + // in case a storage is open for reading it must exist + try + { + xTempSubStorage1.openStreamElement( "NonExistingStorage", ElementModes.READ ); + m_aTestHelper.Error( "The method must throw an exception in case of try to open nonexistent storage for reading!" ); + return false; + } + catch( com.sun.star.uno.Exception ue ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of try to open nonexistent storage for reading : " + e ); + return false; + } + + // in case of removing nonexistent element an exception must be thrown + try + { + xTempSubStorage1.removeElement( "NonExistingElement" ); + m_aTestHelper.Error( "An exception must be thrown in case of removing nonexistent element!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of try to remove nonexistent element : " + e ); + return false; + } + + // in case of renaming of nonexistent element an exception must be thrown + try + { + xTempSubStorage1.renameElement( "NonExistingElement", "NewName" ); + m_aTestHelper.Error( "An exception must be thrown in case of renaming nonexistent element!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of try to rename nonexistent element : " + e ); + return false; + } + + // in case of renaming to a name of existent element an exception must be thrown + try + { + xTempStorage.renameElement( "SubStorage1", "SubStorage2" ); + m_aTestHelper.Error( "An exception must be thrown in case of renaming to the name of existent element!" ); + return false; + } + catch( com.sun.star.container.ElementExistException ee ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of try to rename to the name of existent element : " + e ); + return false; + } + + // in case of copying target storage must be provided + try + { + xTempStorage.copyElementTo( "SubStorage1", null, "SubStorage1" ); + m_aTestHelper.Error( "An exception must be thrown in case empty reference is provided as target for copying!" ); + return false; + } + catch( com.sun.star.lang.IllegalArgumentException iae ) + {} + catch( com.sun.star.uno.Exception ue ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case empty reference is provieded as target for copying : " + e ); + return false; + } + + // in case of moving target storage must be provided + try + { + xTempStorage.moveElementTo( "SubStorage1", null, "SubStorage1" ); + m_aTestHelper.Error( "An exception must be thrown in case empty reference is provided as target for moving!" ); + return false; + } + catch( com.sun.star.lang.IllegalArgumentException iae ) + {} + catch( com.sun.star.uno.Exception ue ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case empty reference is provieded as target for moving : " + e ); + return false; + } + + + // prepare target for further testings + + // create new temporary storage based on arbitrary medium + Object oTargetStorage = m_xStorageFactory.createInstance(); + XStorage xTargetStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTargetStorage ); + if ( xTargetStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTargetSubStorage = m_aTestHelper.openSubStorage( xTargetStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTargetSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // in case of copying of nonexistent element an exception must be thrown + try + { + xTempStorage.copyElementTo( "Nonexistent element", xTargetStorage, "Target" ); + m_aTestHelper.Error( "An exception must be thrown in case of copying of nonexisting element!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of copying of nonexistent element: " + e ); + return false; + } + + // in case of moving of nonexistent element an exception must be thrown + try + { + xTempStorage.moveElementTo( "Nonexistent element", xTargetStorage, "Target" ); + m_aTestHelper.Error( "An exception must be thrown in case of moving of nonexisting element!" ); + return false; + } + catch( com.sun.star.container.NoSuchElementException ne ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case of moving of nonexistent element: " + e ); + return false; + } + + // in case target for copying already exists an exception must be thrown + try + { + xTempStorage.copyElementTo( "SubStorage1", xTargetStorage, "SubStorage1" ); + m_aTestHelper.Error( "An exception must be thrown in case target for copying already exists!" ); + return false; + } + catch( com.sun.star.container.ElementExistException ee ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case target for copying already exists: " + e ); + return false; + } + + // in case target for moving already exists an exception must be thrown + try + { + xTempStorage.moveElementTo( "SubStorage1", xTargetStorage, "SubStorage1" ); + m_aTestHelper.Error( "An exception must be thrown in case target for moving already exists!" ); + return false; + } + catch( com.sun.star.container.ElementExistException ee ) + {} + catch( Exception e ) + { + m_aTestHelper.Error( "Unexpected excepion in case target for moving already exists: " + e ); + return false; + } + + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test07.java b/package/qa/storages/Test07.java new file mode 100644 index 000000000000..970c6f13ec09 --- /dev/null +++ b/package/qa/storages/Test07.java @@ -0,0 +1,162 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test07 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test07( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test07: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + String sPass1 = "12345"; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "BigSubStream1", "MediaType1", true, pBigBytes, sPass1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes1, sPass1 ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + String sPass2 = "54321"; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "BigSubStream2", "MediaType2", false, pBigBytes, sPass2 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream2", "MediaType2", false, pBytes2, sPass2 ) ) + return false; + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.WRITE ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + Object o2CopyStorage = m_xStorageFactory.createInstance(); + XStorage x2CopyStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, o2CopyStorage ); + if ( x2CopyStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + if ( !m_aTestHelper.copyStorage( xResultStorage, x2CopyStorage ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "SubStream1", "MediaType1", pBytes1, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "BigSubStream1", "MediaType1", pBigBytes, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "SubStream2", "MediaType2", pBytes2, sPass2 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "BigSubStream2", "MediaType2", pBigBytes, sPass2 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( x2CopyStorage, "SubStream1", "MediaType1", pBytes1, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( x2CopyStorage, "BigSubStream1", "MediaType1", pBigBytes, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( x2CopyStorage, "SubStream2", "MediaType2", pBytes2, sPass2 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( x2CopyStorage, "BigSubStream2", "MediaType2", pBigBytes, sPass2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test08.java b/package/qa/storages/Test08.java new file mode 100644 index 000000000000..5e024db588c8 --- /dev/null +++ b/package/qa/storages/Test08.java @@ -0,0 +1,230 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test08 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test08( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test08: " ); + } + + public boolean test() + { + try + { + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // set the global password for the root storage + XEncryptionProtectedSource xTempStorageEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xTempStorage ); + + if ( xTempStorageEncryption == null ) + { + m_aTestHelper.Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" ); + return true; + } + + String sPass1 = "123"; + String sPass2 = "321"; + + try { + xTempStorageEncryption.setEncryptionPassword( sPass1 ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't set a common encryption key for the storage, exception:" + e ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will be encrypted with common password + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + if ( !m_aTestHelper.WBToSubstrOfEncr( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1, true ) ) + return false; + if ( !m_aTestHelper.WBToSubstrOfEncr( xTempSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes, true ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will not be encrypted + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + if ( !m_aTestHelper.WBToSubstrOfEncr( xTempSubStorage, "SubStream2", "MediaType2", false, pBytes2, false ) ) + return false; + if ( !m_aTestHelper.WBToSubstrOfEncr( xTempSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes, false ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will be compressed with own password + byte pBytes3[] = { 3, 3, 3, 3, 3 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will not be encrypted + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubStream3", "MediaType3", false, pBytes3, sPass2 ) ) + return false; + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "BigSubStream3", "MediaType3", false, pBigBytes, sPass2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType4", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType5", + false, + ElementModes.WRITE ) ) + return false; + + // create temporary file + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType4", true, ElementModes.READ ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType5", false, ElementModes.READ ) ) + return false; + + // set the global password for the root storage + XEncryptionProtectedSource xResultStorageEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xResultStorage ); + + if ( xResultStorageEncryption == null ) + { + m_aTestHelper.Error( "XEncryptionProtectedSource was successfully used already, so it must be supported!" ); + return false; + } + + try { + xResultStorageEncryption.setEncryptionPassword( sPass2 ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't set a common encryption key for the storage, exception:" + e ); + return false; + } + + if ( !m_aTestHelper.checkEncrStream( xResultSubStorage, "SubStream1", "MediaType1", pBytes1, sPass1 ) ) + return false; + if ( !m_aTestHelper.checkEncrStream( xResultSubStorage, "BigSubStream1", "MediaType1", pBigBytes, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream2", "MediaType2", false, pBytes2 ) ) + return false; + if ( !m_aTestHelper.checkStream( xResultSubStorage, "BigSubStream2", "MediaType2", false, pBigBytes ) ) + return false; + + // the common root storage password should allow to open this stream + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream3", "MediaType3", true, pBytes3 ) ) + return false; + if ( !m_aTestHelper.checkStream( xResultSubStorage, "BigSubStream3", "MediaType3", true, pBigBytes ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/Test09.java b/package/qa/storages/Test09.java new file mode 100644 index 000000000000..2ce2dfb1e484 --- /dev/null +++ b/package/qa/storages/Test09.java @@ -0,0 +1,138 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test09 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test09( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test09: " ); + } + + public boolean test() + { + try + { + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + String sPass1 = "123"; + String sPass2 = "321"; + byte pBytes[] = { 1, 1, 1, 1, 1 }; + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + // the stream will not be encrypted + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", false, pBytes, sPass1 ) ) + return false; + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "BigSubStream1", "MediaType1", false, pBigBytes, sPass1 ) ) + return false; + + // create temporary file + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // change password of the substream of new storage based on file + int nResult = m_aTestHelper.ChangeStreamPass( xTempFileStorage, "SubStream1", sPass1, sPass2 ); + if ( nResult == 0 ) + return false; // test failed + else if ( nResult == -1 ) + return true; // tested optional feature is not supported + + // change password of the substream of new storage based on file + nResult = m_aTestHelper.ChangeStreamPass( xTempFileStorage, "BigSubStream1", sPass1, sPass2 ); + if ( nResult == 0 ) + return false; // test failed + else if ( nResult == -1 ) + return true; // tested optional feature is not supported + + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "SubStream1", "MediaType1", pBytes, sPass2 ) ) + return false; + if ( !m_aTestHelper.checkEncrStream( xResultStorage, "BigSubStream1", "MediaType1", pBigBytes, sPass2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/Test10.java b/package/qa/storages/Test10.java new file mode 100644 index 000000000000..162daa5abe29 --- /dev/null +++ b/package/qa/storages/Test10.java @@ -0,0 +1,232 @@ +package complex.storages; + +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.container.XNameAccess; +import com.sun.star.io.XStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test10 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test10( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test10: " ); + } + + public boolean test() + { + try + { + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream2", "MediaType2", true, pBytes2 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream2", "MediaType2", true, pBigBytes ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // ============================== + // check cloning at current state + // ============================== + + // the new storage still was not commited so the clone must be empty + XStorage xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" ); + + if ( xClonedSubStorage == null ) + { + m_aTestHelper.Error( "The result of clone is empty!" ); + return false; + } + + XNameAccess xClonedNameAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xClonedSubStorage ); + if ( xClonedNameAccess == null ) + { + m_aTestHelper.Error( "XNameAccess is not implemented by the clone!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xClonedSubStorage, "", true, ElementModes.WRITE ) ) + return false; + + if ( xClonedNameAccess.hasElements() ) + { + m_aTestHelper.Error( "The new substorage still was not commited so it must be empty!" ); + return false; + } + + if ( !m_aTestHelper.disposeStorage( xClonedSubStorage ) ) + return false; + + xClonedSubStorage = null; + xClonedNameAccess = null; + + // the new stream was opened, written and closed, that means flashed + // so the clone must contain all the information + XStream xClonedSubStream = m_aTestHelper.cloneSubStream( xTempStorage, "SubStream1" ); + if ( !m_aTestHelper.InternalCheckStream( xClonedSubStream, "SubStream1", "MediaType1", true, pBytes1, true ) ) + return false; + + XStream xClonedBigSubStream = m_aTestHelper.cloneSubStream( xTempStorage, "BigSubStream1" ); + if ( !m_aTestHelper.InternalCheckStream( xClonedBigSubStream, "BigSubStream1", "MediaType1", true, pBigBytes, true ) ) + return false; + + if ( !m_aTestHelper.disposeStream( xClonedSubStream, "SubStream1" ) ) + return false; + + if ( !m_aTestHelper.disposeStream( xClonedBigSubStream, "BigSubStream1" ) ) + return false; + + // ============================== + // commit substorage and check cloning + // ============================== + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" ); + if ( xClonedSubStorage == null ) + { + m_aTestHelper.Error( "The result of clone is empty!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xClonedSubStorage, "MediaType4", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStream( xClonedSubStorage, "SubStream2", "MediaType2", true, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xClonedSubStorage, "BigSubStream2", "MediaType2", true, pBigBytes ) ) + return false; + + XStorage xCloneOfRoot = m_aTestHelper.cloneStorage( m_xStorageFactory, xTempStorage ); + if ( xCloneOfRoot == null ) + { + m_aTestHelper.Error( "The result of root clone is empty!" ); + return false; + } + + XNameAccess xCloneOfRootNA = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xCloneOfRoot ); + if ( xCloneOfRootNA == null ) + { + m_aTestHelper.Error( "XNameAccess is not implemented by the root clone!" ); + return false; + } + + if ( xCloneOfRootNA.hasElements() ) + { + m_aTestHelper.Error( "The root storage still was not commited so it's clone must be empty!" ); + return false; + } + + if ( !m_aTestHelper.disposeStorage( xCloneOfRoot ) ) + return false; + + xCloneOfRoot = null; + + // ============================== + // commit root storage and check cloning + // ============================== + + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + xCloneOfRoot = m_aTestHelper.cloneStorage( m_xStorageFactory, xTempStorage ); + if ( xCloneOfRoot == null ) + { + m_aTestHelper.Error( "The result of root clone is empty!" ); + return false; + } + + XStorage xSubStorageOfClone = xCloneOfRoot.openStorageElement( "SubStorage1", ElementModes.READ ); + if ( xSubStorageOfClone == null ) + { + m_aTestHelper.Error( "The result of root clone is wrong!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xSubStorageOfClone, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xSubStorageOfClone, "SubStream2", "MediaType2", true, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xSubStorageOfClone, "BigSubStream2", "MediaType2", true, pBigBytes ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/Test11.java b/package/qa/storages/Test11.java new file mode 100644 index 000000000000..198fa41fe588 --- /dev/null +++ b/package/qa/storages/Test11.java @@ -0,0 +1,218 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.container.XNameAccess; +import com.sun.star.io.XStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test11 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test11( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test11: " ); + } + + public boolean test() + { + try + { + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + String sPass1 = "111111111"; + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "SubStream1", "MediaType1", true, pBytes1, sPass1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempStorage, "BigSubStream1", "MediaType1", true, pBigBytes, sPass1 ) ) + return false; + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + String sPass2 = "2222222222"; + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "SubStream2", "MediaType2", true, pBytes2, sPass2 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToEncrSubstream( xTempSubStorage, "BigSubStream2", "MediaType2", true, pBigBytes, sPass2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // ============================== + // check cloning at current state + // ============================== + + // the new storage still was not commited so the clone must be empty + XStorage xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" ); + + if ( xClonedSubStorage == null ) + { + m_aTestHelper.Error( "The result of clone is empty!" ); + return false; + } + + XNameAccess xClonedNameAccess = (XNameAccess) UnoRuntime.queryInterface( XNameAccess.class, xClonedSubStorage ); + if ( xClonedNameAccess == null ) + { + m_aTestHelper.Error( "XNameAccess is not implemented by the clone!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xClonedSubStorage, "", true, ElementModes.WRITE ) ) + return false; + + if ( xClonedNameAccess.hasElements() ) + { + m_aTestHelper.Error( "The new substorage still was not commited so it must be empty!" ); + return false; + } + + if ( !m_aTestHelper.disposeStorage( xClonedSubStorage ) ) + return false; + + xClonedSubStorage = null; + xClonedNameAccess = null; + + // the new stream was opened, written and closed, that means flashed + // so the clone must contain all the information + XStream xClonedSubStream = m_aTestHelper.cloneEncrSubStream( xTempStorage, "SubStream1", sPass1 ); + if ( !m_aTestHelper.InternalCheckStream( xClonedSubStream, "SubStream1", "MediaType1", true, pBytes1, true ) ) + return false; + + XStream xClonedBigSubStream = m_aTestHelper.cloneEncrSubStream( xTempStorage, "BigSubStream1", sPass1 ); + if ( !m_aTestHelper.InternalCheckStream( xClonedBigSubStream, "BigSubStream1", "MediaType1", true, pBigBytes, true ) ) + return false; + + if ( !m_aTestHelper.disposeStream( xClonedSubStream, "SubStream1" ) ) + return false; + + if ( !m_aTestHelper.disposeStream( xClonedBigSubStream, "BigSubStream1" ) ) + return false; + + // ============================== + // commit substorage and check cloning + // ============================== + + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" ); + if ( xClonedSubStorage == null ) + { + m_aTestHelper.Error( "The result of clone is empty!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xClonedSubStorage, "MediaType4", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xClonedSubStorage, "SubStream2", "MediaType2", pBytes2, sPass2 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xClonedSubStorage, "BigSubStream2", "MediaType2", pBigBytes, sPass2 ) ) + return false; + + // ============================== + // commit the root storage and check cloning + // ============================== + + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + XStorage xCloneOfRoot = m_aTestHelper.cloneStorage( m_xStorageFactory, xTempStorage ); + if ( xCloneOfRoot == null ) + { + m_aTestHelper.Error( "The result of root clone is empty!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xCloneOfRoot, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xCloneOfRoot, "SubStream1", "MediaType1", pBytes1, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xCloneOfRoot, "BigSubStream1", "MediaType1", pBigBytes, sPass1 ) ) + return false; + + XStorage xSubStorageOfClone = xCloneOfRoot.openStorageElement( "SubStorage1", ElementModes.READ ); + if ( xSubStorageOfClone == null ) + { + m_aTestHelper.Error( "The result of root clone is wrong!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xSubStorageOfClone, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xSubStorageOfClone, "SubStream2", "MediaType2", pBytes2, sPass2 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStream( xSubStorageOfClone, "BigSubStream2", "MediaType2", pBigBytes, sPass2 ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } +} + diff --git a/package/qa/storages/Test12.java b/package/qa/storages/Test12.java new file mode 100644 index 000000000000..05928cf76b0d --- /dev/null +++ b/package/qa/storages/Test12.java @@ -0,0 +1,240 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test12 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test12( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test12: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType2", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType3", + false, + ElementModes.WRITE ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose substorage + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + + // ================================================ + // check substorage + // ================================================ + + if ( !checkSubStorages( xTempStorage, pBytes1, pBigBytes ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + // ================================================ + // now check all the written information with readwrite access + // ================================================ + + Object oResWriteStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResWriteStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResWriteStorage ); + if ( xResWriteStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResWriteStorage, "MediaType2", true, ElementModes.WRITE ) ) + return false; + + if( !checkSubStorages( xResWriteStorage, pBytes1, pBigBytes ) ) + return false; + + // try to open for writing after opening for reading + XStorage xResWSubStorage = m_aTestHelper.openSubStorage( xResWriteStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xResWSubStorage == null ) + { + m_aTestHelper.Error( "Can't open substorage for writing after it was opened for reading!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResWSubStorage, "MediaType3", false, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResWSubStorage, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResWSubStorage, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xResWriteStorage ) ) + return false; + + + // ================================================ + // now check all the written information with readonly access + // ================================================ + + // close the output part of the temporary stream + // the output part must present since we already wrote to the stream + if ( !m_aTestHelper.closeOutput( xTempFileStream ) ) + return false; + + XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream ); + if ( xTempInStream == null ) + return false; + + // open input stream + // since no mode is provided the result storage must be opened readonly + Object pOneArg[] = new Object[1]; + pOneArg[0] = (Object) xTempInStream; + + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType2", true, ElementModes.READ ) ) + return false; + + if( !checkSubStorages( xResultStorage, pBytes1, pBigBytes ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + + private boolean checkSubStorages( XStorage xStorage, byte[] pBytes1, byte[] pBigBytes ) + { + XStorage xReadSubStorage1 = m_aTestHelper.openSubStorage( xStorage, + "SubStorage1", + ElementModes.READ ); + + XStorage xReadSubStorage2 = m_aTestHelper.openSubStorage( xStorage, + "SubStorage1", + ElementModes.READ ); + + if ( xReadSubStorage1 == null || xReadSubStorage2 == null ) + { + m_aTestHelper.Error( "Can't open substorage for reading!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xReadSubStorage1, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStorageProperties( xReadSubStorage2, "MediaType3", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xReadSubStorage1, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xReadSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStream( xReadSubStorage2, "SubStream1", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xReadSubStorage2, "BigSubStream1", "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xReadSubStorage1 ) ) + return false; + + if ( !m_aTestHelper.disposeStorage( xReadSubStorage2 ) ) + return false; + + return true; + } +} + diff --git a/package/qa/storages/Test13.java b/package/qa/storages/Test13.java new file mode 100644 index 000000000000..e8b05264f44d --- /dev/null +++ b/package/qa/storages/Test13.java @@ -0,0 +1,215 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test13 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test13( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test13: " ); + } + + public boolean test() + { + String aStreamPrefix = ""; + for ( int nInd = 0; nInd < 4; ++nInd, aStreamPrefix += "SubStorage" + nInd ) + if ( !testForPath( aStreamPrefix ) ) + return false; + + return true; + } + + public boolean testForPath( String aStreamPrefix ) + { + try + { + String aSubStream1Path = aStreamPrefix + "SubStream1"; + String aSubStream2Path = aStreamPrefix + "SubStream2"; + String aSubStream3Path = aStreamPrefix + "SubStream3"; + String aBigSubStream1Path = aStreamPrefix + "BigSubStream1"; + String aBigSubStream2Path = aStreamPrefix + "BigSubStream2"; + String aBigSubStream3Path = aStreamPrefix + "BigSubStream3"; + + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + byte pBigBytes[] = new byte[33000]; + for ( int nInd = 0; nInd < 33000; nInd++ ) + pBigBytes[nInd] = (byte)( nInd % 128 ); + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1, true ) ) + return false; + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aBigSubStream1Path, "MediaType1", true, pBigBytes, true ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2, true ) ) + return false; + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aBigSubStream2Path, "MediaType2", false, pBigBytes, true ) ) + return false; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream3Path, "MediaType2", false, pBytes2, false ) ) + return false; + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aBigSubStream3Path, "MediaType2", false, pBigBytes, false ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written and copied information + // and change it + // ================================================ + + // the temporary file must not be locked any more after storage disposing + oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempFileStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aBigSubStream1Path, "MediaType1", true, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aBigSubStream2Path, "MediaType2", false, pBigBytes ) ) + return false; + + if ( !m_aTestHelper.cantOpenStreamH( xTempFileStorage, aSubStream3Path, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.cantOpenStreamH( xTempFileStorage, aBigSubStream3Path, ElementModes.READ ) ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream1Path, "MediaType3", true, pBytes2, true ) ) + return false; + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aBigSubStream1Path, "MediaType3", true, pBigBytes, true ) ) + return false; + + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream2Path, "MediaType3", true, pBytes1, false ) ) + return false; + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aBigSubStream2Path, "MediaType3", true, pBigBytes, false ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xResultStorage, aSubStream1Path, "MediaType3", true, pBytes2 ) ) + return false; + if ( !m_aTestHelper.checkStreamH( xResultStorage, aBigSubStream1Path, "MediaType3", true, pBigBytes ) ) + return false; + + // the following stream was not commited last time, so the last change must be lost + if ( !m_aTestHelper.checkStreamH( xResultStorage, aBigSubStream2Path, "MediaType2", false, pBigBytes ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test14.java b/package/qa/storages/Test14.java new file mode 100644 index 000000000000..1f35758af05a --- /dev/null +++ b/package/qa/storages/Test14.java @@ -0,0 +1,188 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test14 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test14( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test14: " ); + } + + public boolean test() + { + String aStreamPrefix = ""; + for ( int nInd = 0; nInd < 4; ++nInd, aStreamPrefix += "SubStorage" + nInd ) + if ( !testForPath( aStreamPrefix ) ) + return false; + + return true; + } + + public boolean testForPath( String aStreamPrefix ) + { + try + { + String aSubStream1Path = aStreamPrefix + "SubStream1"; + String aSubStream2Path = aStreamPrefix + "SubStream2"; + String aSubStream3Path = aStreamPrefix + "SubStream3"; + + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + String sPass1 = "12345"; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1, sPass1, true ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + String sPass2 = "54321"; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2, sPass2, true ) ) + return false; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream3Path, "MediaType2", false, pBytes2, sPass2, false ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written and copied information + // and change it + // ================================================ + + // the temporary file must not be locked any more after storage disposing + oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xTempFileStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkEncrStreamH( xTempFileStorage, aSubStream1Path, "MediaType1", pBytes1, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", pBytes2, sPass2 ) ) + return false; + + if ( !m_aTestHelper.cantOpenEncrStreamH( xTempFileStorage, aSubStream3Path, ElementModes.READ, sPass2 ) ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream1Path, "MediaType3", true, pBytes2, sPass1, true ) ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream2Path, "MediaType3", true, pBytes1, sPass2, false ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkEncrStreamH( xResultStorage, aSubStream1Path, "MediaType3", pBytes2, sPass1 ) ) + return false; + + // the following stream was not commited last time, so the last change must be lost + if ( !m_aTestHelper.checkEncrStreamH( xResultStorage, aSubStream2Path, "MediaType2", pBytes2, sPass2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test15.java b/package/qa/storages/Test15.java new file mode 100644 index 000000000000..b58453f9a195 --- /dev/null +++ b/package/qa/storages/Test15.java @@ -0,0 +1,268 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test15 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test15( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test15: " ); + } + + public boolean test() + { + String aStreamPrefix = ""; + for ( int nInd = 0; nInd < 4; ++nInd, aStreamPrefix += "SubStorage" + nInd ) + if ( !testForPath( aStreamPrefix ) ) + return false; + + return true; + } + + public boolean testForPath( String aStreamPrefix ) + { + try + { + String aSubStream1Path = aStreamPrefix + "SubStream1"; + String aSubStream2Path = aStreamPrefix + "SubStream2"; + String aSubStream3Path = aStreamPrefix + "SubStream3"; + String aSubStream4Path = aStreamPrefix + "SubStream4"; + + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // set the global password for the root storage + XEncryptionProtectedSource xTempStorageEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xTempFileStorage ); + + if ( xTempStorageEncryption == null ) + { + m_aTestHelper.Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" ); + return true; + } + + String sPass1 = "12345"; + String sPass2 = "54321"; + + try { + xTempStorageEncryption.setEncryptionPassword( sPass1 ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't set a common encryption key for the storage, exception:" + e ); + return false; + } + + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WBToSubstrOfEncrH( xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1, true, true ) ) + return false; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2, sPass2, true ) ) + return false; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream3Path, "MediaType3", false, pBytes2, sPass2, true ) ) + return false; + + // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and dont commit + if ( !m_aTestHelper.WBToSubstrOfEncrH( xTempFileStorage, aSubStream4Path, "MediaType2", true, pBytes1, true, false ) ) + return false; + + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempFileStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written and copied information + // and change it + // ================================================ + + // the temporary file must not be locked any more after storage disposing + oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // set the global password for the root storage + xTempStorageEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xTempFileStorage ); + + if ( xTempStorageEncryption == null ) + { + m_aTestHelper.Error( "XEncryptionProtectedSource is supported, but can not be retrieved!" ); + return false; + } + + try { + xTempStorageEncryption.setEncryptionPassword( sPass2 ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't set a common encryption key for the storage, exception:" + e ); + return false; + } + + + if ( !m_aTestHelper.checkStorageProperties( xTempFileStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + if ( !m_aTestHelper.checkEncrStreamH( xTempFileStorage, aSubStream1Path, "MediaType1", pBytes1, sPass1 ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aSubStream2Path, "MediaType2", true, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xTempFileStorage, aSubStream3Path, "MediaType3", true, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.cantOpenEncrStreamH( xTempFileStorage, aSubStream4Path, ElementModes.READ, sPass1 ) ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and commit + if ( !m_aTestHelper.WriteBytesToEncrStreamH( xTempFileStorage, aSubStream1Path, "MediaType4", true, pBytes2, sPass1, true ) ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream2Path, "MediaType5", true, pBytes1, true ) ) + return false; + + // change the password of the existing stream + if ( m_aTestHelper.ChangeStreamPassH( xTempFileStorage, aSubStream2Path, sPass2, sPass1, true ) != 1 ) + return false; + + // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it, write some bytes + // and don't commit + if ( !m_aTestHelper.WriteBytesToStreamH( xTempFileStorage, aSubStream3Path, "MediaType5", true, pBytes1, false ) ) + return false; + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now reopen the storage, + // check all the written information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.READ ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + // set the global password for the root storage + xTempStorageEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xResultStorage ); + + if ( xTempStorageEncryption == null ) + { + m_aTestHelper.Error( "XEncryptionProtectedSource is supported, but can not be retrieved!" ); + return false; + } + + try { + xTempStorageEncryption.setEncryptionPassword( sPass1 ); + } + catch( Exception e ) + { + m_aTestHelper.Error( "Can't set a common encryption key for the storage, exception:" + e ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xResultStorage, aSubStream1Path, "MediaType4", true, pBytes2 ) ) + return false; + + if ( !m_aTestHelper.checkStreamH( xResultStorage, aSubStream2Path, "MediaType5", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkEncrStreamH( xResultStorage, aSubStream3Path, "MediaType3", pBytes2, sPass2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test16.java b/package/qa/storages/Test16.java new file mode 100644 index 000000000000..6f432b0da730 --- /dev/null +++ b/package/qa/storages/Test16.java @@ -0,0 +1,159 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test16 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test16( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test16: " ); + } + + public boolean test() + { + try + { + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage\u0442\u0435\u0441\u04421", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream\u0442\u0435\u0441\u04421", "MediaType1", true, pBytes1 ) ) + return false; + + byte pBytes2[] = { 2, 2, 2, 2, 2 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, "SubStream\u0442\u0435\u0441\u04422", "MediaType2", false, pBytes2 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.WRITE ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage\u0442\u0435\u0441\u04421", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream\u0442\u0435\u0441\u04421", "MediaType1", true, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream\u0442\u0435\u0441\u04422", "MediaType2", false, pBytes2 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test17.java b/package/qa/storages/Test17.java new file mode 100644 index 000000000000..009344cefbc4 --- /dev/null +++ b/package/qa/storages/Test17.java @@ -0,0 +1,142 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.io.XStream; +import com.sun.star.io.XInputStream; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test17 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test17( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test17: " ); + } + + public boolean test() + { + try + { + XStream xTempFileStream = m_aTestHelper.CreateTempFileStream( m_xMSF ); + if ( xTempFileStream == null ) + return false; + + // create storage based on the temporary stream + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) xTempFileStream; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + String pNames[] = { "SubStream1", "SubStream2", "SubStream3", "SubStream4", "SubStream5", "SubStream6", "SubStream7" }; + + for ( int nInd = 0; nInd < pNames.length; nInd++ ) + { + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubStorage, pNames[nInd], "MediaType1", true, pBytes1 ) ) + return false; + + // commit substorage first + if ( !m_aTestHelper.commitStorage( xTempSubStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) ) + return false; + } + + // commit the root storage so the contents must be stored now + if ( !m_aTestHelper.commitStorage( xTempStorage ) ) + return false; + + // dispose used storage to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) ) + return false; + + + // ================================================ + // now check all the written information + // ================================================ + + // close the output part of the temporary stream + // the output part must present since we already wrote to the stream + if ( !m_aTestHelper.closeOutput( xTempFileStream ) ) + return false; + + XInputStream xTempInStream = m_aTestHelper.getInputStream( xTempFileStream ); + if ( xTempInStream == null ) + return false; + + + // open input stream + // since no mode is provided the result storage must be opened readonly + Object pOneArg[] = new Object[1]; + pOneArg[0] = (Object) xTempInStream; + + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pOneArg ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't open storage based on input stream!" ); + return false; + } + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + for ( int nInd = 0; nInd < pNames.length; nInd++ ) + if ( !m_aTestHelper.checkStream( xResultSubStorage, pNames[nInd], "MediaType1", true, pBytes1 ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/Test18.java b/package/qa/storages/Test18.java new file mode 100644 index 000000000000..335a230027ce --- /dev/null +++ b/package/qa/storages/Test18.java @@ -0,0 +1,172 @@ +package complex.storages; + +import com.sun.star.uno.XInterface; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.lang.XSingleServiceFactory; + +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +import com.sun.star.embed.*; + +import share.LogWriter; +import complex.storages.TestHelper; +import complex.storages.StorageTest; + +public class Test18 implements StorageTest { + + XMultiServiceFactory m_xMSF; + XSingleServiceFactory m_xStorageFactory; + TestHelper m_aTestHelper; + + public Test18( XMultiServiceFactory xMSF, XSingleServiceFactory xStorageFactory, LogWriter aLogWriter ) + { + m_xMSF = xMSF; + m_xStorageFactory = xStorageFactory; + m_aTestHelper = new TestHelper( aLogWriter, "Test18: " ); + } + + public boolean test() + { + try + { + // test the default value of Compressed property + String sTempFileURL = m_aTestHelper.CreateTempFile( m_xMSF ); + if ( sTempFileURL == null || sTempFileURL == "" ) + { + m_aTestHelper.Error( "No valid temporary file was created!" ); + return false; + } + + // create temporary storage based on arbitrary medium + // after such a storage is closed it is lost + Object oTempStorage = m_xStorageFactory.createInstance(); + XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xTempStorage == null ) + { + m_aTestHelper.Error( "Can't create temporary storage representation!" ); + return false; + } + + // open a new substorage + XStorage xTempSubStorage = m_aTestHelper.openSubStorage( xTempStorage, + "SubStorage1", + ElementModes.WRITE ); + if ( xTempSubStorage == null ) + { + m_aTestHelper.Error( "Can't create substorage!" ); + return false; + } + + byte pBytes1[] = { 1, 1, 1, 1, 1 }; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstreamDefaultCompressed( xTempSubStorage, "SubStream1", "image/jpeg", pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstreamDefaultCompressed( xTempSubStorage, "SubStream2", "image/png", pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstreamDefaultCompressed( xTempSubStorage, "SubStream3", "image/gif", pBytes1 ) ) + return false; + + // open a new substream, set "MediaType" and "Compressed" properties to it and write some bytes + if ( !m_aTestHelper.WriteBytesToSubstreamDefaultCompressed( xTempSubStorage, "SubStream4", "MediaType1", pBytes1 ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempStorage, + "MediaType3", + true, + ElementModes.WRITE ) ) + return false; + + // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are set correctly + if ( !m_aTestHelper.setStorageTypeAndCheckProps( xTempSubStorage, + "MediaType4", + false, + ElementModes.WRITE ) ) + return false; + + // create temporary storage based on a previously created temporary file + Object pArgs[] = new Object[2]; + pArgs[0] = (Object) sTempFileURL; + pArgs[1] = new Integer( ElementModes.WRITE ); + + Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xTempFileStorage = (XStorage)UnoRuntime.queryInterface( XStorage.class, oTempFileStorage ); + if ( xTempFileStorage == null ) + { + m_aTestHelper.Error( "Can't create storage based on temporary file!" ); + return false; + } + + // copy xTempStorage to xTempFileStorage + // xTempFileStorage will be automatically commited + if ( !m_aTestHelper.copyStorage( xTempStorage, xTempFileStorage ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) ) + return false; + + // ================================================ + // now check all the written and copied information + // ================================================ + + // the temporary file must not be locked any more after storage disposing + pArgs[1] = new Integer( ElementModes.WRITE ); + Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs ); + XStorage xResultStorage = (XStorage) UnoRuntime.queryInterface( XStorage.class, oResultStorage ); + if ( xResultStorage == null ) + { + m_aTestHelper.Error( "Can't reopen storage based on temporary file!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultStorage, "MediaType3", true, ElementModes.WRITE ) ) + return false; + + // open existing substorage + XStorage xResultSubStorage = m_aTestHelper.openSubStorage( xResultStorage, + "SubStorage1", + ElementModes.READ ); + if ( xResultSubStorage == null ) + { + m_aTestHelper.Error( "Can't open existing substorage!" ); + return false; + } + + if ( !m_aTestHelper.checkStorageProperties( xResultSubStorage, "MediaType4", false, ElementModes.READ ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream1", "image/jpeg", false, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream2", "image/png", false, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream3", "image/gif", false, pBytes1 ) ) + return false; + + if ( !m_aTestHelper.checkStream( xResultSubStorage, "SubStream4", "MediaType1", true, pBytes1 ) ) + return false; + + // dispose used storages to free resources + if ( !m_aTestHelper.disposeStorage( xResultStorage ) ) + return false; + + return true; + } + catch( Exception e ) + { + m_aTestHelper.Error( "Exception: " + e ); + return false; + } + } + +} + diff --git a/package/qa/storages/TestHelper.java b/package/qa/storages/TestHelper.java new file mode 100644 index 000000000000..dc28786513b1 --- /dev/null +++ b/package/qa/storages/TestHelper.java @@ -0,0 +1,1661 @@ +package complex.storages; + +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.*; + +import share.LogWriter; + +public class TestHelper { + + LogWriter m_aLogWriter; + String m_sTestPrefix; + + public TestHelper( LogWriter aLogWriter, String sTestPrefix ) + { + m_aLogWriter = aLogWriter; + 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 = (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 = (XPropertySet) 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; + } + + return true; + } + + public boolean WriteBytesToSubstreamDefaultCompressed( XStorage xStorage, + String sStreamName, + String sMediaType, + byte[] pBytes ) + { + // open substream element + XStream xSubStream = null; + try + { + Object oSubStream = xStorage.openStreamElement( sStreamName, ElementModes.WRITE ); + xSubStream = (XStream) 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 output stream of substream + XOutputStream xOutput = xSubStream.getOutputStream(); + if ( xOutput == null ) + { + Error( "Can't get XOutputStream implementation from substream '" + sStreamName + "'!" ); + return false; + } + + // get XTrucate implementation from output stream + XTruncate 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 = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xSubStream ); + if ( xPropSet == null ) + { + Error( "Can't get XPropertySet implementation from substream '" + sStreamName + "'!" ); + return false; + } + + // set properties to the stream + // do not set the compressed property + try + { + xPropSet.setPropertyValue( "MediaType", sMediaType ); + } + 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 + if ( !disposeStream( xSubStream, sStreamName ) ) + return false; + + 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.WRITE ); + xSubStream = (XStream) 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; + } + + if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) ) + return false; + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamName ) ) + return false; + + return true; + } + + public boolean WriteBytesToEncrSubstream( XStorage xStorage, + String sStreamName, + String sMediaType, + boolean bCompressed, + byte[] pBytes, + String sPass ) + { + // open substream element + XStream xSubStream = null; + try + { + Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, sPass ); + xSubStream = (XStream) 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; + } + + if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) ) + return false; + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamName ) ) + return false; + + return true; + } + + 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.WRITE ); + xSubStream = (XStream) 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 = (XPropertySet) 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( "UseCommonStoragePasswordEncryption", new Boolean( bEncrypted ) ); + } + catch( Exception e ) + { + Error( "Can't set 'UseCommonStoragePasswordEncryption' property to substream '" + sStreamName + "', exception: " + e ); + return false; + } + + if ( !WriteBytesToStream( xSubStream, sStreamName, sMediaType, bCompressed, pBytes ) ) + return false; + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamName ) ) + return false; + + return true; + } + + public boolean WriteBytesToStreamH( XStorage xStorage, + String sStreamPath, + String sMediaType, + boolean bCompressed, + byte[] pBytes, + boolean bCommit ) + { + // open substream element + XStream xSubStream = null; + try + { + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sStreamPath, ElementModes.WRITE ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't create substream '" + sStreamPath + "'!" ); + return false; + } + } + catch( Exception e ) + { + Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" ); + return false; + } + + if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) ) + return false; + + XTransactedObject xTransact = + (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream ); + if ( xTransact == null ) + { + Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" ); + return false; + } + + if ( bCommit ) + { + try { + xTransact.commit(); + } catch( Exception e ) + { + Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" ); + return false; + } + } + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamPath ) ) + return false; + + return true; + } + + public boolean WriteBytesToEncrStreamH( XStorage xStorage, + String sStreamPath, + String sMediaType, + boolean bCompressed, + byte[] pBytes, + String sPass, + boolean bCommit ) + { + // open substream element + XStream xSubStream = null; + try + { + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sStreamPath, + ElementModes.WRITE, + sPass ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't create substream '" + sStreamPath + "'!" ); + return false; + } + } + catch( Exception e ) + { + Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" ); + return false; + } + + if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) ) + return false; + + XTransactedObject xTransact = + (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream ); + if ( xTransact == null ) + { + Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" ); + return false; + } + + if ( bCommit ) + { + try { + xTransact.commit(); + } catch( Exception e ) + { + Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" ); + return false; + } + } + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamPath ) ) + return false; + + return true; + } + + public boolean WBToSubstrOfEncrH( XStorage xStorage, + String sStreamPath, + String sMediaType, + boolean bCompressed, + byte[] pBytes, + boolean bEncrypted, + boolean bCommit ) + { + // open substream element + XStream xSubStream = null; + try + { + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sStreamPath, ElementModes.WRITE ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't create substream '" + sStreamPath + "'!" ); + return false; + } + } + catch( Exception e ) + { + Error( "Can't create substream '" + sStreamPath + "', exception : " + e + "!" ); + return false; + } + + // get access to the XPropertySet interface + XPropertySet xPropSet = (XPropertySet) UnoRuntime.queryInterface( XPropertySet.class, xSubStream ); + if ( xPropSet == null ) + { + Error( "Can't get XPropertySet implementation from substream '" + sStreamPath + "'!" ); + return false; + } + + // set properties to the stream + try + { + xPropSet.setPropertyValue( "UseCommonStoragePasswordEncryption", new Boolean( bEncrypted ) ); + } + catch( Exception e ) + { + Error( "Can't set 'UseCommonStoragePasswordEncryption' property to substream '" + sStreamPath + "', exception: " + e ); + return false; + } + + if ( !WriteBytesToStream( xSubStream, sStreamPath, sMediaType, bCompressed, pBytes ) ) + return false; + + XTransactedObject xTransact = + (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream ); + if ( xTransact == null ) + { + Error( "Substream '" + sStreamPath + "', stream opened for writing must be transacted!" ); + return false; + } + + if ( bCommit ) + { + try { + xTransact.commit(); + } catch( Exception e ) + { + Error( "Can't commit storage after substream '" + sStreamPath + "' change, exception : " + e + "!" ); + return false; + } + } + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sStreamPath ) ) + return false; + + return true; + } + + public int ChangeStreamPass( XStorage xStorage, + String sStreamName, + String sOldPass, + String sNewPass ) + { + // open substream element + XStream xSubStream = null; + try + { + Object oSubStream = xStorage.openEncryptedStreamElement( sStreamName, ElementModes.WRITE, sOldPass ); + xSubStream = (XStream) 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 = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream ); + + if ( xStreamEncryption == null ) + { + Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" ); + return -1; + } + + try { + xStreamEncryption.setEncryptionPassword( sNewPass ); + } + 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 + if ( !disposeStream( xSubStream, sStreamName ) ) + return 0; + + return 1; + } + + public int ChangeStreamPassH( XStorage xStorage, + String sPath, + String sOldPass, + String sNewPass, + boolean bCommit ) + { + // open substream element + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return 0; + } + + XStream xSubStream = null; + try + { + Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.WRITE, sOldPass ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't open encrypted substream '" + sPath + "'!" ); + return 0; + } + } + catch( Exception e ) + { + Error( "Can't open encrypted substream '" + sPath + "', exception : " + e + "!" ); + return 0; + } + + // change the password for the stream + XEncryptionProtectedSource xStreamEncryption = + (XEncryptionProtectedSource) UnoRuntime.queryInterface( XEncryptionProtectedSource.class, xSubStream ); + + if ( xStreamEncryption == null ) + { + Message( "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!" ); + return -1; + } + + try { + xStreamEncryption.setEncryptionPassword( sNewPass ); + } + catch( Exception e ) + { + Error( "Can't change encryption key of the substream '" + sPath + "', exception:" + e ); + return 0; + } + + XTransactedObject xTransact = + (XTransactedObject) UnoRuntime.queryInterface( XTransactedObject.class, xSubStream ); + if ( xTransact == null ) + { + Error( "Substream '" + sPath + "', stream opened for writing must be transacted!" ); + return 0; + } + + if ( bCommit ) + { + try { + xTransact.commit(); + } catch( Exception e ) + { + Error( "Can't commit storage after substream '" + sPath + "' change, exception : " + e + "!" ); + return 0; + } + } + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sPath ) ) + return 0; + + return 1; + } + + public boolean setStorageTypeAndCheckProps( XStorage xStorage, String sMediaType, boolean bIsRoot, int nMode ) + { + boolean bOk = false; + + // get access to the XPropertySet interface + XPropertySet xPropSet = (XPropertySet) 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.READ ) != ( nMode | ElementModes.READ ) ) + || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) ) + { + Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" ); + 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 = (XPropertySet) 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.READ ) != ( nMode | ElementModes.READ ) ) + || ( !bIsRoot && ( nPropMode & nMode ) != nMode ) ) + { + Error( "'OpenMode' property contains wrong value, expected " + nMode + ", in reality " + nPropMode + "!" ); + 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, + boolean bCompressed, + byte[] pBytes, + boolean bCheckCompressed ) + { + // 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! ( byte num. " + + ind + " should be " + pBytes[ind] + " but it is " + pContents[0][ind] + ")" ); + return false; + } + } + + // check properties + boolean bOk = false; + + // get access to the XPropertySet interface + XPropertySet xPropSet = (XPropertySet) 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" ) ); + boolean bPropCompress = AnyConverter.toBoolean( xPropSet.getPropertyValue( "Compressed" ) ); + + 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; + } + + if ( bCheckCompressed && bPropCompress != bCompressed ) + { + Error( "'Compressed' 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, + boolean bCompressed, + byte[] pBytes ) + { + // open substream element first + XStream xSubStream = null; + try + { + Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.READ ); + xSubStream = (XStream) 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; + } + + boolean bResult = InternalCheckStream( xSubStream, sName, sMediaType, bCompressed, pBytes, true ); + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sName ) ) + return false; + + return bResult; + } + + public boolean checkEncrStream( XStorage xParentStorage, + String sName, + String sMediaType, + byte[] pBytes, + String sPass ) + { + // Important: a common password for any of parent storage should not be set or + // should be different from sPass + + try + { + Object oSubStream = xParentStorage.openStreamElement( sName, ElementModes.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; + } + + String sWrongPass = "11"; + sWrongPass += sPass; + try + { + Object oSubStream = xParentStorage.openEncryptedStreamElement( sName, ElementModes.READ, sWrongPass ); + 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.READ, sPass ); + xSubStream = (XStream) 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; + } + + // encrypted streams will be compressed always, so after the storing this property is always true, + // although before the storing it can be set to false ( it is not always clear whether a stream is encrypted + // before the storing ) + boolean bResult = InternalCheckStream( xSubStream, sName, sMediaType, true, pBytes, false ); + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sName ) ) + return false; + + return bResult; + } + + public boolean checkStreamH( XStorage xParentStorage, + String sPath, + String sMediaType, + boolean bCompressed, + byte[] pBytes ) + { + // open substream element first + XStream xSubStream = null; + try + { + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xParentStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sPath, ElementModes.READ ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't open substream '" + sPath + "'!" ); + return false; + } + } + catch( Exception e ) + { + Error( "Can't open substream '" + sPath + "', exception : " + e + "!" ); + return false; + } + + boolean bResult = InternalCheckStream( xSubStream, sPath, sMediaType, bCompressed, pBytes, true ); + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sPath ) ) + return false; + + return bResult; + } + + public boolean checkEncrStreamH( XStorage xParentStorage, + String sPath, + String sMediaType, + byte[] pBytes, + String sPass ) + { + // Important: a common password for any of parent storage should not be set or + // should be different from sPass + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xParentStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + try + { + Object oSubStream = xHStorage.openStreamElementByHierarchicalName( sPath, ElementModes.READ ); + XStream xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + Error( "Encrypted substream '" + sPath + "' was opened without password!" ); + return false; + } + catch( WrongPasswordException wpe ) + {} + catch( Exception e ) + { + Error( "Unexpected exception in case of opening of encrypted stream '" + sPath + "' without password: " + e + "!" ); + return false; + } + + String sWrongPass = "11"; + sWrongPass += sPass; + try + { + Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.READ, sWrongPass ); + XStream xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + Error( "Encrypted substream '" + sPath + "' was opened with wrong password!" ); + return false; + } + catch( WrongPasswordException wpe ) + {} + catch( Exception e ) + { + Error( "Unexpected exception in case of opening of encrypted stream '" + sPath + "' with wrong password: " + e + "!" ); + return false; + } + + XStream xSubStream = null; + try + { + Object oSubStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, ElementModes.READ, sPass ); + xSubStream = (XStream) UnoRuntime.queryInterface( XStream.class, oSubStream ); + if ( xSubStream == null ) + { + Error( "Can't open encrypted substream '" + sPath + "'!" ); + return false; + } + } + catch( Exception e ) + { + Error( "Can't open encrypted substream '" + sPath + "', exception : " + e + "!" ); + return false; + } + + // encrypted streams will be compressed always, so after the storing this property is always true, + // although before the storing it can be set to false ( it is not always clear whether a stream is encrypted + // before the storing ) + boolean bResult = InternalCheckStream( xSubStream, sPath, sMediaType, true, pBytes, false ); + + // free the stream resources, garbage collector may remove the object too late + if ( !disposeStream( xSubStream, sPath ) ) + return false; + + return bResult; + } + + 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 = (XTransactedObject) 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 disposeStream( XStream xStream, String sStreamName ) + { + XComponent xComponent = (XComponent) UnoRuntime.queryInterface( XComponent.class, xStream ); + if ( xComponent == null ) + { + Error( "Can't get XComponent implementation from substream '" + sStreamName + "'!" ); + return false; + } + + try + { + xComponent.dispose(); + } + catch( Exception e ) + { + Error( "Substream '" + sStreamName + "' disposing throws exception: " + e ); + return false; + } + + return true; + } + + public boolean disposeStorage( XStorage xStorage ) + { + // dispose the storage + XComponent 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 = (XStorage) 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 = (XStream)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 = (XPropertySet)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 = (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 copyElementTo( XStorage xSource, String sName, XStorage xDest, String sTargetName ) + { + // copy element with name sName from xSource to xDest + try + { + xSource.copyElementTo( sName, xDest, sTargetName ); + } + 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 = (XStream) 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 compareRawMethodsOnEncrStream( XStorage xStorage, String sStreamName ) + { + + XStorageRawAccess xRawStorage; + try + { + xRawStorage = (XStorageRawAccess) UnoRuntime.queryInterface( XStorageRawAccess.class, xStorage ); + } + catch( Exception e ) + { + Error( "Can't get raw access to the storage, exception : " + e + "!" ); + return false; + } + + if ( xRawStorage == null ) + { + Error( "Can't get raw access to the storage!" ); + return false; + } + + XInputStream xHeadRawStream = null; + try + { + xHeadRawStream = xRawStorage.getRawEncrStreamElement( sStreamName ); + } + catch( Exception e ) + { + Error( "Can't open encrypted stream '" + sStreamName + "' in raw mode with header, exception : " + e + "!" ); + } + + XInputStream xPlainRawStream = null; + try + { + xPlainRawStream = xRawStorage.getPlainRawStreamElement( sStreamName ); + } + catch( Exception e ) + { + Error( "Can't open encrypted stream '" + sStreamName + "' in raw mode with header, exception : " + e + "!" ); + } + + if ( xHeadRawStream == null || xPlainRawStream == null ) + { + Error( "Can't open encrypted stream '" + sStreamName + "' in raw modes!" ); + return false; + } + + try + { + byte pData[][] = new byte[1][22]; + if ( xHeadRawStream.readBytes( pData, 22 ) != 22 ) + { + Error( "Can't read header of encrypted stream '" + sStreamName + "' raw representations!" ); + return false; + } + + if ( pData[0][0] != 0x4d || pData[0][1] != 0x47 || pData[0][2] != 0x02 || pData[0][3] != 0x05 ) + { + Error( "No signature in the header of encrypted stream '" + sStreamName + "' raw representations!" ); + return false; + } + + int nVariableHeaderLength = + ( pData[0][14] + pData[0][15] * 0x100 ) // salt length + + ( pData[0][16] + pData[0][17] * 0x100 ) // iv length + + ( pData[0][18] + pData[0][19] * 0x100 ) // digest length + + ( pData[0][20] + pData[0][21] * 0x100 ); // mediatype length + + xHeadRawStream.skipBytes( nVariableHeaderLength ); + + byte pRawData1[][] = new byte[1][32000]; + byte pRawData2[][] = new byte[1][32000]; + int nRead1 = 0; + int nRead2 = 0; + + do + { + nRead1 = xHeadRawStream.readBytes( pRawData1, 32000 ); + nRead2 = xPlainRawStream.readBytes( pRawData2, 32000 ); + + if ( nRead1 != nRead2 ) + { + Error( "The encrypted stream '" + sStreamName + "' raw representations have different size!" ); + return false; + } + + for ( int nInd = 0; nInd < nRead1; nInd++ ) + if ( pRawData1[0][nInd] != pRawData2[0][nInd] ) + { + Error( "The encrypted stream '" + sStreamName + "' raw representations have different data!" ); + return false; + } + } + while( nRead1 == 32000 ); + } + catch ( Exception e ) + { + Error( "Can't compare stream '" + sStreamName + "' raw representations, exception : " + e + "!" ); + return false; + } + + return true; + } + + public boolean cantOpenStorage( XStorage xStorage, String sName ) + { + // try to open an opened substorage, open call must fail + try + { + Object oDummyStorage = xStorage.openStorageElement( sName, ElementModes.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 substream '" + sName + "' must fail!" ); + } + catch( Exception e ) + { + return true; + } + + return false; + } + + public boolean cantOpenStreamH( XStorage xStorage, String sPath, int nMode ) + { + // try to open the substream with specified mode must fail + + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + try + { + Object oDummyStream = xHStorage.openStreamElementByHierarchicalName( sPath, nMode ); + Error( "The trying to open substream '" + sPath + "' must fail!" ); + } + catch( Exception e ) + { + return true; + } + + return false; + } + + public boolean cantOpenEncrStreamH( XStorage xStorage, String sPath, int nMode, String aPass ) + { + // try to open the substream with specified mode must fail + + XHierarchicalStorageAccess xHStorage = + (XHierarchicalStorageAccess) UnoRuntime.queryInterface( XHierarchicalStorageAccess.class, xStorage ); + if ( xHStorage == null ) + { + Error( "The storage does not support hierarchical access!" ); + return false; + } + + try + { + Object oDummyStream = xHStorage.openEncryptedStreamElementByHierarchicalName( sPath, nMode, aPass ); + Error( "The trying to open substream '" + sPath + "' must fail!" ); + } + catch( WrongPasswordException wpe ) + { + Error( "The substream '" + sPath + "' must not exist!" ); + return false; + } + catch( Exception e ) + { + return true; + } + + return false; + } + + public XStorage cloneStorage( XSingleServiceFactory xFactory, XStorage xStorage ) + { + // create a copy of a last commited version of specified storage + XStorage xResult = null; + try + { + Object oTempStorage = xFactory.createInstance(); + xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xResult != null ) + xStorage.copyLastCommitTo( xResult ); + } + catch( Exception e ) + { + Error( "Can't clone storage, exception: " + e ); + return null; + } + + return xResult; + } + + public XStorage cloneSubStorage( XSingleServiceFactory xFactory, XStorage xStorage, String sName ) + { + // create a copy of a last commited version of specified substorage + XStorage xResult = null; + try + { + Object oTempStorage = xFactory.createInstance(); + xResult = (XStorage) UnoRuntime.queryInterface( XStorage.class, oTempStorage ); + if ( xResult != null ) + xStorage.copyStorageElementLastCommitTo( sName, xResult ); + } + catch( Exception e ) + { + Error( "Can't clone substorage '" + sName + "', exception: " + e ); + return null; + } + + return xResult; + } + + public XStream cloneSubStream( XStorage xStorage, String sName ) + { + // clone existing substream + try + { + XStream xStream = xStorage.cloneStreamElement( sName ); + return xStream; + } + catch( Exception e ) + { + Error( "Can't clone substream '" + sName + "', exception: " + e ); + } + + return null; + } + + public XStream cloneEncrSubStream( XStorage xStorage, String sName, String sPass ) + { + // clone existing substream + try + { + XStream xStream = xStorage.cloneEncryptedStreamElement( sName, sPass ); + return xStream; + } + catch( Exception e ) + { + Error( "Can't clone encrypted substream '" + sName + "', exception: " + e ); + } + + return null; + } + + public void Error( String sError ) + { + m_aLogWriter.println( m_sTestPrefix + "Error: " + sError ); + } + + public void Message( String sMessage ) + { + m_aLogWriter.println( m_sTestPrefix + sMessage ); + } +} + diff --git a/package/qa/storages/makefile.mk b/package/qa/storages/makefile.mk new file mode 100644 index 000000000000..95fe75a03e74 --- /dev/null +++ b/package/qa/storages/makefile.mk @@ -0,0 +1,116 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************* + +PRJ = ..$/.. +TARGET = StorageUnitTest +PRJNAME = package +PACKAGE = complex$/storages + +# --- Settings ----------------------------------------------------- +.INCLUDE: settings.mk + + +#----- compile .java files ----------------------------------------- + +JARFILES = ridl.jar unoil.jar jurt.jar juh.jar java_uno.jar OOoRunner.jar + +JAVAFILES =\ + StorageUnitTest.java\ + StorageTest.java\ + TestHelper.java\ + BorderedStream.java\ + Test01.java\ + Test02.java\ + Test03.java\ + Test04.java\ + Test05.java\ + Test06.java\ + Test07.java\ + Test08.java\ + Test09.java\ + Test10.java\ + Test11.java\ + Test12.java\ + Test13.java\ + Test14.java\ + Test15.java\ + Test16.java\ + Test17.java\ + Test18.java\ + RegressionTest_114358.java\ + RegressionTest_i29169.java\ + RegressionTest_i30400.java\ + RegressionTest_i29321.java\ + RegressionTest_i30677.java\ + RegressionTest_i27773.java\ + RegressionTest_i46848.java\ + RegressionTest_i55821.java\ + RegressionTest_i35095.java\ + RegressionTest_i49755.java\ + RegressionTest_i59886.java\ + RegressionTest_i61909.java\ + RegressionTest_i84234.java\ + RegressionTest_125919.java + +JAVACLASSFILES = $(foreach,i,$(JAVAFILES) $(CLASSDIR)$/$(PACKAGE)$/$(i:b).class) + +#----- make a jar from compiled files ------------------------------ + +MAXLINELENGTH = 100000 + +JARCLASSDIRS = $(PACKAGE) +JARTARGET = $(TARGET).jar +JARCOMPRESS = TRUE + +# --- Parameters for the test -------------------------------------- + +# start an office if the parameter is set for the makefile +.IF "$(OFFICE)" == "" +CT_APPEXECCOMMAND = +.ELSE +CT_APPEXECCOMMAND = -AppExecutionCommand "$(OFFICE)$/soffice -accept=socket,host=localhost,port=8100;urp;" +.ENDIF + +# test base is java complex +CT_TESTBASE = -TestBase java_complex + +# test looks something like the.full.package.TestName +CT_TEST = -o $(PACKAGE:s\$/\.\).$(JAVAFILES:b) + +# start the runner application +CT_APP = org.openoffice.Runner + +# --- Targets ------------------------------------------------------ + +.INCLUDE: target.mk + +RUN: run + +run: + java -cp $(CLASSPATH) $(CT_APP) $(CT_TESTBASE) $(CT_APPEXECCOMMAND) $(CT_TEST) + + |