mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove visual noise from package

Browse Source 
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>
This commit is contained in:
Alexander Wilms 2014-02-25 19:38:36 +01:00 committed by Caolán McNamara
parent 132d7941e0
commit d148739576
41 changed files with 191 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
package/qa/ofopxmlstorages/Test01.java
View File

@ -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,

4
package/qa/ofopxmlstorages/Test02.java
View File

@ -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

4
package/qa/ofopxmlstorages/Test03.java
View File

@ -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 {

4
package/qa/ofopxmlstorages/Test04.java
View File

@ -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,

4
package/qa/ofopxmlstorages/Test05.java
View File

@ -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,

12
package/qa/ofopxmlstorages/Test07.java
View File

@ -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;

12
package/qa/ofopxmlstorages/Test08.java
View File

@ -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

58
package/qa/storages/BorderedStream.java
View File

@ -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
{

8
package/qa/storages/RegressionTest_114358.java
View File

@ -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 );

8
package/qa/storages/RegressionTest_i26398.java
View File

@ -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,

12
package/qa/storages/RegressionTest_i27773.java
View File

@ -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 );

24
package/qa/storages/RegressionTest_i29169.java
View File

@ -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 );

8
package/qa/storages/RegressionTest_i29321.java
View File

@ -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;

36
package/qa/storages/RegressionTest_i30400.java
View File

@ -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 );

24
package/qa/storages/RegressionTest_i30677.java
View File

@ -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 );

4
package/qa/storages/RegressionTest_i35095.java
View File

@ -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

8
package/qa/storages/RegressionTest_i46848.java
View File

@ -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 );

8
package/qa/storages/RegressionTest_i49755.java
View File

@ -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

8
package/qa/storages/RegressionTest_i55821.java
View File

@ -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 );

8
package/qa/storages/RegressionTest_i59886.java
View File

@ -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;

8
package/qa/storages/RegressionTest_i61909.java
View File

@ -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 );

8
package/qa/storages/RegressionTest_i84234.java
View File

@ -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 );

4
package/qa/storages/Test01.java
View File

@ -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 );

4
package/qa/storages/Test02.java
View File

@ -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

4
package/qa/storages/Test03.java
View File

@ -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 {

4
package/qa/storages/Test04.java
View File

@ -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 );

4
package/qa/storages/Test05.java
View File

@ -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 );

4
package/qa/storages/Test07.java
View File

@ -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 );

4
package/qa/storages/Test08.java
View File

@ -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 );

4
package/qa/storages/Test09.java
View File

@ -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 );

12
package/qa/storages/Test10.java
View File

@ -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;

12
package/qa/storages/Test11.java
View File

@ -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;

12
package/qa/storages/Test12.java
View File

@ -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

8
package/qa/storages/Test13.java
View File

@ -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 );

8
package/qa/storages/Test14.java
View File

@ -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 );

8
package/qa/storages/Test15.java
View File

@ -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 );

4
package/qa/storages/Test16.java
View File

@ -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 );

4
package/qa/storages/Test17.java
View File

@ -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

4
package/qa/storages/Test18.java
View File

@ -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 );

2
package/source/xstor/switchpersistencestream.hxx
View File

@ -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!

2
package/source/xstor/xstorage.cxx
View File

@ -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 ) ) );
// }