Remove visual noise from package

Change-Id: Icef40ad2d451d3c5ca90ed4b305ece5430d352f7
Reviewed-on: https://gerrit.libreoffice.org/8289
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

package/qa/ofopxmlstorages/Test01.java

@@ -151,9 +151,9 @@ public class Test01 implements StorageTest {
             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
             XStorage xResultStorage = m_aTestHelper.createStorageFromURL( m_xStorageFactory,

package/qa/ofopxmlstorages/Test02.java

@@ -125,9 +125,9 @@ public class Test02 implements StorageTest {
                 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

package/qa/ofopxmlstorages/Test03.java

@@ -115,9 +115,9 @@ public class Test03 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
                 return false;
 
-            // ================================================
+
             // check storage hyerarchy tree
-            // ================================================
+
 
             // check that isStorageElement() and isStreamElement reacts to nonexisting object correctly
             try {

package/qa/ofopxmlstorages/Test04.java

@@ -210,9 +210,9 @@ public class Test04 implements StorageTest {
             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
             XStorage xResStorage = m_aTestHelper.createStorageFromURL( m_xStorageFactory,

package/qa/ofopxmlstorages/Test05.java

@@ -249,9 +249,9 @@ public class Test05 implements StorageTest {
                 return false;
 
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             XStorage xResultStorage = m_aTestHelper.createStorageFromURL( m_xStorageFactory,
                                                                             sTempFileURL,

package/qa/ofopxmlstorages/Test07.java

@@ -127,9 +127,9 @@ public class Test07 implements StorageTest {
                                                             aRelations2 ) )
                 return false;
 
-            // ==============================
+
             // check cloning at current state
-            // ==============================
+
 
             // the new storage still was not commited so the clone must be empty
             XStorage xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xMSF, m_xStorageFactory, xTempStorage, "SubStorage1" );
@@ -178,9 +178,9 @@ public class Test07 implements StorageTest {
             if ( !m_aTestHelper.disposeStream( xClonedSubStream, "SubStream1" ) )
                 return false;
 
-            // ==============================
+
             // commit substorage and check cloning
-            // ==============================
+
 
             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
                 return false;
@@ -230,9 +230,9 @@ public class Test07 implements StorageTest {
 
             xCloneOfRoot = null;
 
-            // ==============================
+
             // commit root storage and check cloning
-            // ==============================
+
 
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;

package/qa/ofopxmlstorages/Test08.java

@@ -123,9 +123,9 @@ public class Test08 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
                 return false;
 
-            // ================================================
+
             // check substorage
-            // ================================================
+
 
             if ( !checkSubStorages( xTempStorage, pBytes1, aRelations1 ) )
                 return false;
@@ -134,9 +134,9 @@ public class Test08 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written information with readwrite access
-            // ================================================
+
 
             XStorage xResWriteStorage = m_aTestHelper.createStorageFromStream( m_xStorageFactory,
                                                                             xTempFileStream,
@@ -184,9 +184,9 @@ public class Test08 implements StorageTest {
                 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

package/qa/storages/BorderedStream.java

@@ -49,29 +49,29 @@ public class BorderedStream
         m_pBytes = new byte[m_nMaxSize];
     }
 
-    //==============
-    // XStream
-    //==============
 
-    // ----------------------------------------------------------
+    // 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
-    //==============
 
-    // ----------------------------------------------------------
+    // 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
     {
@@ -97,14 +97,14 @@ public class BorderedStream
         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
     {
@@ -117,14 +117,14 @@ public class BorderedStream
             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
     {
@@ -132,11 +132,11 @@ public class BorderedStream
     }
 
 
-    //==============
-    // XOutputStream
-    //==============
 
-    // ----------------------------------------------------------
+    // 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
     {
@@ -154,14 +154,14 @@ public class BorderedStream
         }
     }
 
-    // ----------------------------------------------------------
+
     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
     {
@@ -169,11 +169,11 @@ public class BorderedStream
     }
 
 
-    //==============
-    // XTruncate
-    //==============
 
-    // ----------------------------------------------------------
+    // XTruncate
+
+
+
     public synchronized void truncate()
         throws com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
     {
@@ -182,11 +182,11 @@ public class BorderedStream
     }
 
 
-    //==============
-    // XSeekable
-    //==============
 
-    // ----------------------------------------------------------
+    // XSeekable
+
+
+
     public synchronized void seek( long location )
         throws com.sun.star.lang.IllegalArgumentException, com.sun.star.io.IOException, com.sun.star.uno.RuntimeException
     {
@@ -196,14 +196,14 @@ public class BorderedStream
         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
     {

package/qa/storages/RegressionTest_114358.java

@@ -114,10 +114,10 @@ public class RegressionTest_114358 implements StorageTest {
             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 };
 
@@ -159,9 +159,9 @@ public class RegressionTest_114358 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // create a new readonly storage based on the stream and check the contents
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/RegressionTest_i26398.java

@@ -99,10 +99,10 @@ public class RegressionTest_i26398 implements StorageTest {
                 return false;
 
 
-            // ================================================
+
             // commit the substorage, dispose it, reopen readonly
             // and dispose the reopened substorage
-            // ================================================
+
 
             // commit substorage
             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
@@ -126,9 +126,9 @@ public class RegressionTest_i26398 implements StorageTest {
             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,

package/qa/storages/RegressionTest_i27773.java

@@ -36,9 +36,9 @@ import share.LogWriter;
 import complex.storages.TestHelper;
 import complex.storages.StorageTest;
 
-///////////////////////////////////
+
 // Tests also fix for i51352
-///////////////////////////////////
+
 
 public class RegressionTest_i27773 implements StorageTest {
 
@@ -167,10 +167,10 @@ public class RegressionTest_i27773 implements StorageTest {
             if ( !m_aTestHelper.copyElementTo( xTempStorage, "EmptySubStorage1", xTempStorage, "EmptySubStorage1_copy" ) )
                 return false;
 
-            // ================================================
+
             // copy all the changed and noncommited substorages
             // and dispose them
-            // ================================================
+
 
             if ( !m_aTestHelper.commitStorage( xEmptySubSubStorage ) )
                 return false;
@@ -198,9 +198,9 @@ public class RegressionTest_i27773 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // reopen the storage in readonly mode an check contents
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
 

package/qa/storages/RegressionTest_i29169.java

@@ -120,9 +120,9 @@ public class RegressionTest_i29169 implements StorageTest {
                                                             ElementModes.WRITE ) )
                 return false;
 
-            // ================================================
+
             // commit the storages, and check the renaming in all stages
-            // ================================================
+
 
             // rename the storage before it is commited
             if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage1", "SubSubStorage2" ) )
@@ -180,9 +180,9 @@ public class RegressionTest_i29169 implements StorageTest {
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // dispose the storages
-            // ================================================
+
 
             // dispose lowerest substorage
             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
@@ -196,9 +196,9 @@ public class RegressionTest_i29169 implements StorageTest {
             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 );
@@ -245,9 +245,9 @@ public class RegressionTest_i29169 implements StorageTest {
             if ( !m_aTestHelper.checkStream( xTempSubSubStorage, "SubSubStream1", "MediaType2", true, pBytes1 ) )
                 return false;
 
-            // ================================================
+
             // rename the reopened storages and streams
-            // ================================================
+
 
             // rename the storage before it is commited
             if ( !m_aTestHelper.renameElement( xTempSubStorage, "SubSubStorage5", "SubSubStorage6" ) )
@@ -305,9 +305,9 @@ public class RegressionTest_i29169 implements StorageTest {
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // dispose the storages
-            // ================================================
+
 
             // dispose lowerest substorage
             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
@@ -322,9 +322,9 @@ public class RegressionTest_i29169 implements StorageTest {
                 return false;
 
 
-            // ================================================
+
             // create a new readonly storage based on the stream and check the contents
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/RegressionTest_i29321.java

@@ -123,9 +123,9 @@ public class RegressionTest_i29321 implements StorageTest {
                                                             ElementModes.WRITE ) )
                 return false;
 
-            // ================================================
+
             // commit the storages twice to test the bug scenario
-            // ================================================
+
 
             // commit lowlevel substorage first
             if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) )
@@ -151,9 +151,9 @@ public class RegressionTest_i29321 implements StorageTest {
             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;

package/qa/storages/RegressionTest_i30400.java

@@ -51,10 +51,10 @@ public class RegressionTest_i30400 implements StorageTest {
     {
         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 )
@@ -138,16 +138,16 @@ public class RegressionTest_i30400 implements StorageTest {
                                                             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 ) )
@@ -161,9 +161,9 @@ public class RegressionTest_i30400 implements StorageTest {
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // dispose the storages
-            // ================================================
+
 
             // dispose lowerest substorage
             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
@@ -177,9 +177,9 @@ public class RegressionTest_i30400 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // reopen the target storage readonly, and check the copying with renaming
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );
@@ -233,10 +233,10 @@ public class RegressionTest_i30400 implements StorageTest {
     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 )
@@ -302,9 +302,9 @@ public class RegressionTest_i30400 implements StorageTest {
         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 ) )
@@ -318,9 +318,9 @@ public class RegressionTest_i30400 implements StorageTest {
         if ( !m_aTestHelper.commitStorage( xTempStorage2 ) )
             return false;
 
-        // ================================================
+
         // dispose the storages
-        // ================================================
+
 
         // dispose lowerest substorage
         if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage2 ) )
@@ -334,9 +334,9 @@ public class RegressionTest_i30400 implements StorageTest {
         if ( !m_aTestHelper.disposeStorage( xTempStorage2 ) )
             return false;
 
-        // ================================================
+
         // reopen the target storage readonly, and check the contents
-        // ================================================
+
 
         pArgs[1] = new Integer( ElementModes.READ );
         oTempStorage2 = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/RegressionTest_i30677.java

@@ -115,9 +115,9 @@ public class RegressionTest_i30677 implements StorageTest {
                                                             ElementModes.WRITE ) )
                 return false;
 
-            // ================================================
+
             // commit the storages
-            // ================================================
+
 
             // commit lowlevel substorage first
             if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) )
@@ -131,9 +131,9 @@ public class RegressionTest_i30677 implements StorageTest {
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // dispose the storages
-            // ================================================
+
 
             // dispose lowerest substorage
             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
@@ -147,9 +147,9 @@ public class RegressionTest_i30677 implements StorageTest {
             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 );
@@ -187,9 +187,9 @@ public class RegressionTest_i30677 implements StorageTest {
             if ( !m_aTestHelper.WriteBytesToSubstream( xTempSubSubStorage, "SubSubStream1", "MediaType1", true, pBytes2 ) )
                 return false;
 
-            // ================================================
+
             // commit the storages
-            // ================================================
+
 
             // commit lowlevel substorage first
             if ( !m_aTestHelper.commitStorage( xTempSubSubStorage ) )
@@ -203,9 +203,9 @@ public class RegressionTest_i30677 implements StorageTest {
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // dispose the storages
-            // ================================================
+
 
             // dispose lowerest substorage
             if ( !m_aTestHelper.disposeStorage( xTempSubSubStorage ) )
@@ -219,9 +219,9 @@ public class RegressionTest_i30677 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // reopen the storages and check the contents
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/RegressionTest_i35095.java

@@ -118,10 +118,10 @@ public class RegressionTest_i35095 implements StorageTest {
             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

package/qa/storages/RegressionTest_i46848.java

@@ -114,10 +114,10 @@ public class RegressionTest_i46848 implements StorageTest {
             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 );
@@ -160,9 +160,9 @@ public class RegressionTest_i46848 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // create a new readonly storage based on the stream and check the contents
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             oTempStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/RegressionTest_i49755.java

@@ -158,10 +158,10 @@ public class RegressionTest_i49755 implements StorageTest {
             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 );
@@ -196,10 +196,10 @@ public class RegressionTest_i49755 implements StorageTest {
                 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

package/qa/storages/RegressionTest_i55821.java

@@ -50,10 +50,10 @@ public class RegressionTest_i55821 implements StorageTest {
     {
         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 )
@@ -93,9 +93,9 @@ public class RegressionTest_i55821 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) )
                 return false;
 
-            // ================================================
+
             // reopen the target storage readonly, and check contents
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/RegressionTest_i59886.java

@@ -118,10 +118,10 @@ public class RegressionTest_i59886 implements StorageTest {
             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 );
@@ -201,9 +201,9 @@ public class RegressionTest_i59886 implements StorageTest {
             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;

package/qa/storages/RegressionTest_i61909.java

@@ -125,9 +125,9 @@ public class RegressionTest_i61909 implements StorageTest {
             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 );
@@ -149,9 +149,9 @@ public class RegressionTest_i61909 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xStep2TempStorage ) )
                 return false;
 
-            // ================================================
+
             // now access the stream using ZipInputStream
-            // ================================================
+
 
             URI aUri = new URI( sTempFileURL );
             File aFile = new File( aUri );

package/qa/storages/RegressionTest_i84234.java

@@ -89,9 +89,9 @@ public class RegressionTest_i84234 implements StorageTest {
                 return false;
 
 
-            // ================================================
+
             // commit the storages and dispose them
-            // ================================================
+
 
             // commit substorage
             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
@@ -109,9 +109,9 @@ public class RegressionTest_i84234 implements StorageTest {
             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 );

package/qa/storages/Test01.java

@@ -136,9 +136,9 @@ public class Test01 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.WRITE );

package/qa/storages/Test02.java

@@ -119,9 +119,9 @@ public class Test02 implements StorageTest {
                 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

package/qa/storages/Test03.java

@@ -107,9 +107,9 @@ public class Test03 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
                 return false;
 
-            // ================================================
+
             // check storage hyerarchy tree
-            // ================================================
+
 
             // check that isStorageElement() and isStreamElement reacts to nonexisting object correctly
             try {

package/qa/storages/Test04.java

@@ -204,9 +204,9 @@ public class Test04 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.WRITE );

package/qa/storages/Test05.java

@@ -245,9 +245,9 @@ public class Test05 implements StorageTest {
                 return false;
 
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             pArgs[1] = new Integer( ElementModes.READ );
             Object oResultStorage = m_xStorageFactory.createInstanceWithArguments( pArgs );

package/qa/storages/Test07.java

@@ -114,9 +114,9 @@ public class Test07 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.WRITE );

package/qa/storages/Test08.java

@@ -167,9 +167,9 @@ public class Test08 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/Test09.java

@@ -121,9 +121,9 @@ public class Test09 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/Test10.java

@@ -109,9 +109,9 @@ public class Test10 implements StorageTest {
                                                             ElementModes.WRITE ) )
                 return false;
 
-            // ==============================
+
             // check cloning at current state
-            // ==============================
+
 
             // the new storage still was not commited so the clone must be empty
             XStorage xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" );
@@ -160,9 +160,9 @@ public class Test10 implements StorageTest {
             if ( !m_aTestHelper.disposeStream( xClonedBigSubStream, "BigSubStream1" ) )
                 return false;
 
-            // ==============================
+
             // commit substorage and check cloning
-            // ==============================
+
 
             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
                 return false;
@@ -208,9 +208,9 @@ public class Test10 implements StorageTest {
 
             xCloneOfRoot = null;
 
-            // ==============================
+
             // commit root storage and check cloning
-            // ==============================
+
 
             if ( !m_aTestHelper.commitStorage( xTempStorage ) )
                 return false;

package/qa/storages/Test11.java

@@ -111,9 +111,9 @@ public class Test11 implements StorageTest {
                                                             ElementModes.WRITE ) )
                 return false;
 
-            // ==============================
+
             // check cloning at current state
-            // ==============================
+
 
             // the new storage still was not commited so the clone must be empty
             XStorage xClonedSubStorage = m_aTestHelper.cloneSubStorage( m_xStorageFactory, xTempStorage, "SubStorage1" );
@@ -162,9 +162,9 @@ public class Test11 implements StorageTest {
             if ( !m_aTestHelper.disposeStream( xClonedBigSubStream, "BigSubStream1" ) )
                 return false;
 
-            // ==============================
+
             // commit substorage and check cloning
-            // ==============================
+
 
             if ( !m_aTestHelper.commitStorage( xTempSubStorage ) )
                 return false;
@@ -185,9 +185,9 @@ public class Test11 implements StorageTest {
             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;

package/qa/storages/Test12.java

@@ -118,9 +118,9 @@ public class Test12 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempSubStorage ) )
                 return false;
 
-            // ================================================
+
             // check substorage
-            // ================================================
+
 
             if ( !checkSubStorages( xTempStorage, pBytes1, pBigBytes ) )
                 return false;
@@ -129,9 +129,9 @@ public class Test12 implements StorageTest {
             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 );
@@ -171,9 +171,9 @@ public class Test12 implements StorageTest {
                 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

package/qa/storages/Test13.java

@@ -130,11 +130,11 @@ public class Test13 implements StorageTest {
             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 );
@@ -189,10 +189,10 @@ public class Test13 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now reopen the storage,
             // check all the written information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/Test14.java

@@ -119,11 +119,11 @@ public class Test14 implements StorageTest {
             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 );
@@ -164,10 +164,10 @@ public class Test14 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now reopen the storage,
             // check all the written information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/Test15.java

@@ -146,11 +146,11 @@ public class Test15 implements StorageTest {
             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 );
@@ -223,10 +223,10 @@ public class Test15 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now reopen the storage,
             // check all the written information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.READ );

package/qa/storages/Test16.java

@@ -124,9 +124,9 @@ public class Test16 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.WRITE );

package/qa/storages/Test17.java

@@ -106,9 +106,9 @@ public class Test17 implements StorageTest {
                 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

package/qa/storages/Test18.java

@@ -131,9 +131,9 @@ public class Test18 implements StorageTest {
             if ( !m_aTestHelper.disposeStorage( xTempStorage ) || !m_aTestHelper.disposeStorage( xTempFileStorage ) )
                 return false;
 
-            // ================================================
+
             // now check all the written and copied information
-            // ================================================
+
 
             // the temporary file must not be locked any more after storage disposing
             pArgs[1] = new Integer( ElementModes.WRITE );

package/source/xstor/switchpersistencestream.hxx

@@ -35,7 +35,7 @@
 #include <cppuhelper/implbase6.hxx>
 
 // SwitchablePersistenceStream
-//
+
 // Allows to switch the stream persistence on the fly. The target
 // stream ( if not filled by the implementation ) MUST have the same
 // size as the original one!

package/source/xstor/xstorage.cxx

@@ -756,7 +756,7 @@ void OStorage_Impl::CopyToStorage( const uno::Reference< embed::XStorage >& xDes
         // {
         //  // Relations info stream is a writeonly property, introduced only to optimyze copying
         //  // Should be used carefuly since no check for stream consistency is done, and the stream must not stay locked
-        //
+
         //  OUString aRelInfoString = "RelationsInfoStream";
         //  xPropSet->setPropertyValue( aRelInfoString, uno::makeAny( GetSeekableTempCopy( xRelInfoStream, m_xFactory ) ) );
         // }