Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

38 files changed, 10049 insertions, 0 deletions

diff --git a/package/qa/storages/BorderedStream.java b/package/qa/storages/BorderedStream.java
new file mode 100644
index 000000000..ce7ebe55f
--- /dev/null
+++ b/package/qa/storages/BorderedStream.java
@@ -0,0 +1,213 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 000000000..f76216cf2
--- /dev/null
+++ b/package/qa/storages/RegressionTest_114358.java
@@ -0,0 +1,208 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 000000000..3ad8b0e6c
--- /dev/null
+++ b/package/qa/storages/RegressionTest_125919.java
@@ -0,0 +1,152 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = ( Integer.valueOf( nInitInd >> ( ( nInitInd % 2 ) * 8 ) ) ).byteValue();
+                if ( nInitInd < 18000 )
+                    pBytes18[nInitInd] = ( Integer.valueOf( 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] = Integer.valueOf( 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 000000000..ec14400c8
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i26398.java
@@ -0,0 +1,164 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..f5e455192
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i27773.java
@@ -0,0 +1,317 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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", Boolean.FALSE );
+                    }
+                    catch ( Exception e )
+                    {
+                    }
+                }
+            }
+
+            // create storage based on the temporary stream
+            Object pArgs[] = new Object[2];
+            pArgs[0] = (Object) xTempFileStream;
+            pArgs[1] = Integer.valueOf( 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 noncommitted 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 and check contents
+
+
+            pArgs[1] = Integer.valueOf( 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 000000000..12286e758
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i29169.java
@@ -0,0 +1,387 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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 committed
+            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 committed
+            if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage3", "SubSubStorage4" ) )
+                return false;
+
+            // rename the stream after it's parent is committed
+            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 committed
+            if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage4", "SubSubStorage5" ) )
+                return false;
+
+            // rename the stream after it's parent is committed
+            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 committed
+            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 committed
+            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 committed
+            if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage7", "SubSubStorage8" ) )
+                return false;
+
+            // rename the stream after it's parent is committed
+            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 committed
+            if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage8", "SubSubStorage9" ) )
+                return false;
+
+            // rename the stream after it`s parent is committed
+            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] = Integer.valueOf( 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 000000000..8fe980ba9
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i29321.java
@@ -0,0 +1,188 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..39866503b
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i30400.java
@@ -0,0 +1,453 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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] = Integer.valueOf( 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] = Integer.valueOf( 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 000000000..faee91afe
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i30677.java
@@ -0,0 +1,281 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 000000000..0c979466c
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i35095.java
@@ -0,0 +1,184 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..9252766ab
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i46848.java
@@ -0,0 +1,209 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 000000000..d2b32b8b9
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i49755.java
@@ -0,0 +1,290 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..b4be15db4
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i55821.java
@@ -0,0 +1,129 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 000000000..90bf87a7e
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i59886.java
@@ -0,0 +1,261 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..a73d8677f
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i61909.java
@@ -0,0 +1,185 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..7bd8073c6
--- /dev/null
+++ b/package/qa/storages/RegressionTest_i84234.java
@@ -0,0 +1,152 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..e35fd5599
--- /dev/null
+++ b/package/qa/storages/StorageTest.java
@@ -0,0 +1,25 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 000000000..a8e433c3e
--- /dev/null
+++ b/package/qa/storages/StorageUnitTest.java
@@ -0,0 +1,319 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+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 000000000..a5d76bcca
--- /dev/null
+++ b/package/qa/storages/Test01.java
@@ -0,0 +1,195 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..2e3e71254
--- /dev/null
+++ b/package/qa/storages/Test02.java
@@ -0,0 +1,181 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..8e7c1ee30
--- /dev/null
+++ b/package/qa/storages/Test03.java
@@ -0,0 +1,249 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 hierarchy tree
+
+
+            // check that isStorageElement() and isStreamElement reacts to nonexistent object correctly
+            try {
+                xTempStorage.isStorageElement( "does not exist" );
+                m_aTestHelper.Error( "Nonexistent 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( "Nonexistent 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 000000000..78af01789
--- /dev/null
+++ b/package/qa/storages/Test04.java
@@ -0,0 +1,325 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed 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] = Integer.valueOf( 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 completely
+            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 000000000..9138b4f86
--- /dev/null
+++ b/package/qa/storages/Test05.java
@@ -0,0 +1,317 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 than 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] = Integer.valueOf( 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 000000000..7d379f182
--- /dev/null
+++ b/package/qa/storages/Test06.java
@@ -0,0 +1,297 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 exception 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 exception 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 exception 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 exception 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 exception 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 exception 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 exception in case empty reference is provided 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 exception in case empty reference is provided 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 nonexistent element!" );
+                return false;
+            }
+            catch( com.sun.star.container.NoSuchElementException ne )
+            {}
+            catch( Exception e )
+            {
+                m_aTestHelper.Error( "Unexpected exception 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 nonexistent element!" );
+                return false;
+            }
+            catch( com.sun.star.container.NoSuchElementException ne )
+            {}
+            catch( Exception e )
+            {
+                m_aTestHelper.Error( "Unexpected exception 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 exception 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 exception 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 000000000..db0cca5b0
--- /dev/null
+++ b/package/qa/storages/Test07.java
@@ -0,0 +1,180 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..9113ee385
--- /dev/null
+++ b/package/qa/storages/Test08.java
@@ -0,0 +1,248 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..3790ecd8b
--- /dev/null
+++ b/package/qa/storages/Test09.java
@@ -0,0 +1,156 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..6b4a5bb41
--- /dev/null
+++ b/package/qa/storages/Test10.java
@@ -0,0 +1,250 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 committed 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 committed 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 committed 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 000000000..02320db81
--- /dev/null
+++ b/package/qa/storages/Test11.java
@@ -0,0 +1,236 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 committed 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 committed 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 000000000..13850daf4
--- /dev/null
+++ b/package/qa/storages/Test12.java
@@ -0,0 +1,258 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..649f9d88b
--- /dev/null
+++ b/package/qa/storages/Test13.java
@@ -0,0 +1,233 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 committed 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 000000000..04d4a8787
--- /dev/null
+++ b/package/qa/storages/Test14.java
@@ -0,0 +1,206 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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] = Integer.valueOf( 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 committed 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 000000000..a5ac5d0ac
--- /dev/null
+++ b/package/qa/storages/Test15.java
@@ -0,0 +1,286 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 don't 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] = Integer.valueOf( 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 000000000..36e945e74
--- /dev/null
+++ b/package/qa/storages/Test16.java
@@ -0,0 +1,177 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..b81fc240a
--- /dev/null
+++ b/package/qa/storages/Test17.java
@@ -0,0 +1,160 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 000000000..3e0f246d1
--- /dev/null
+++ b/package/qa/storages/Test18.java
@@ -0,0 +1,190 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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] = Integer.valueOf( 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 committed
+            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] = Integer.valueOf( 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 000000000..d6a4fd280
--- /dev/null
+++ b/package/qa/storages/TestHelper.java
@@ -0,0 +1,1679 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+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 XTruncate 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", Boolean.valueOf( bCompressed ) );
+        }
+        catch( Exception e )
+        {
+            Error( "Can't set properties to substream '" + sStreamName + "', exception: " + e );
+            return false;
+        }
+
+        // check size property of the stream
+        try
+        {
+            long nSize = AnyConverter.toLong( 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 XTruncate 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
+        {
+            long nSize = AnyConverter.toLong( 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", Boolean.valueOf( 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", Boolean.valueOf( 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" ) );
+                long nPropSize = AnyConverter.toLong( 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", 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][38];
+            if ( xHeadRawStream.readBytes( pData, 38 ) != 38 )
+            {
+                Error( "Can't read header of encrypted stream '" + sStreamName + "' raw representations!" );
+                return false;
+            }
+
+            if ( pData[0][0] != 0x4d || pData[0][1] != 0x4d || 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][30] + pData[0][31] * 0x100 ) // salt length
+                        + ( pData[0][32] + pData[0][33] * 0x100 ) // iv length
+                        + ( pData[0][34] + pData[0][35] * 0x100 ) // digest length
+                        + ( pData[0][36] + pData[0][37] * 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! nRead1 - nRead2 = " + ( Integer.valueOf( nRead1 - nRead2 ) ).toString() );
+                    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 committed 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 committed 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 000000000..d41284603
--- /dev/null
+++ b/package/qa/storages/makefile.mk
@@ -0,0 +1,109 @@
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+# This file incorporates work covered by the following license notice:
+#
+#   Licensed to the Apache Software Foundation (ASF) under one or more
+#   contributor license agreements. See the NOTICE file distributed
+#   with this work for additional information regarding copyright
+#   ownership. The ASF licenses this file to you under the Apache
+#   License, Version 2.0 (the "License"); you may not use this file
+#   except in compliance with the License. You may obtain a copy of
+#   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+#
+
+
+
+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)
+
+