public boolean test() {
try {
String sTempFileURL = m_aTestHelper.CreateTempFile(m_xMSF);
if (sTempFileURL == null || sTempFileURL == "") {
m_aTestHelper.Error("No valid temporary file was created!");
return false;
}
// create temporary storage based on arbitrary medium
// after such a storage is closed it is lost
Object oTempStorage = m_xStorageFactory.createInstance();
XStorage xTempStorage = (XStorage) UnoRuntime.queryInterface(XStorage.class, oTempStorage);
if (xTempStorage == null) {
m_aTestHelper.Error("Can't create temporary storage representation!");
return false;
}
// open substorages and create streams there
// first substorage of the root storage
XStorage xTempSubStorage1 =
m_aTestHelper.openSubStorage(xTempStorage, "SubStorage1", ElementModes.WRITE);
if (xTempSubStorage1 == null) {
m_aTestHelper.Error("Can't create substorage!");
return false;
}
byte pBigBytes[] = new byte[33000];
for (int nInd = 0; nInd < 33000; nInd++) pBigBytes[nInd] = (byte) (nInd % 128);
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToSubstream(
xTempSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes)) return false;
byte pBytes1[] = {1, 1, 1, 1, 1};
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToSubstream(
xTempSubStorage1, "SubStream1", "MediaType1", true, pBytes1)) return false;
// second substorage of the root storage
XStorage xTempSubStorage2 =
m_aTestHelper.openSubStorage(xTempStorage, "SubStorage2", ElementModes.WRITE);
if (xTempSubStorage2 == null) {
m_aTestHelper.Error("Can't create substorage!");
return false;
}
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToSubstream(
xTempSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes)) return false;
byte pBytes2[] = {2, 2, 2, 2, 2};
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToSubstream(
xTempSubStorage2, "SubStream2", "MediaType2", false, pBytes2)) return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempStorage, "MediaType3", true, ElementModes.WRITE)) return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempSubStorage1, "MediaType4", false, ElementModes.WRITE)) return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempSubStorage2, "MediaType5", false, ElementModes.WRITE)) return false;
// create temporary storage based on a previously created temporary file
Object pArgs[] = new Object[2];
pArgs[0] = (Object) sTempFileURL;
pArgs[1] = new Integer(ElementModes.WRITE);
Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xTempFileStorage =
(XStorage) UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
if (xTempFileStorage == null) {
m_aTestHelper.Error("Can't create storage based on temporary file!");
return false;
}
if (!m_aTestHelper.copyElementTo(xTempStorage, "SubStorage1", xTempFileStorage)) return false;
// if storage is not commited before disposing all the changes will be lost
if (!m_aTestHelper.commitStorage(xTempSubStorage2)) return false;
// a storage must be disposed before moving/removing otherwise the access will be denied
if (!m_aTestHelper.disposeStorage(xTempSubStorage2)) return false;
if (!m_aTestHelper.moveElementTo(xTempStorage, "SubStorage2", xTempFileStorage)) return false;
// SubStorage2 must be removed and disposed now
try {
xTempSubStorage2.isStreamElement("SubStream2");
m_aTestHelper.Error("SubStorage2 must be disposed already!");
return false;
} catch (com.sun.star.lang.DisposedException de) {
} catch (Exception e) {
m_aTestHelper.Error("Wrong exception in case of disposed storage, exception: " + e);
return false;
}
if (!m_aTestHelper.copyElementTo(xTempSubStorage1, "SubStream1", xTempFileStorage))
return false;
if (!m_aTestHelper.renameElement(xTempFileStorage, "SubStream1", "SubStream1_copy"))
return false;
if (!m_aTestHelper.moveElementTo(xTempSubStorage1, "SubStream1", xTempFileStorage))
return false;
if (!m_aTestHelper.copyElementTo(xTempSubStorage1, "BigSubStream1", xTempFileStorage))
return false;
if (!m_aTestHelper.renameElement(xTempFileStorage, "BigSubStream1", "BigSubStream1_copy"))
return false;
if (!m_aTestHelper.moveElementTo(xTempSubStorage1, "BigSubStream1", xTempFileStorage))
return false;
if (!m_aTestHelper.commitStorage(xTempFileStorage)) return false;
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xTempStorage)
|| !m_aTestHelper.disposeStorage(xTempFileStorage)) return false;
// ================================================
// now check all the written and copied information
// ================================================
// the temporary file must not be locked any more after storage disposing
pArgs[1] = new Integer(ElementModes.WRITE);
Object oResStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xResStorage = (XStorage) UnoRuntime.queryInterface(XStorage.class, oResStorage);
if (xResStorage == null) {
m_aTestHelper.Error("Can't reopen storage based on temporary file!");
return false;
}
// open and check SubStorage1
XStorage xResSubStorage1 =
m_aTestHelper.openSubStorage(xResStorage, "SubStorage1", ElementModes.READ);
if (xResSubStorage1 == null) {
m_aTestHelper.Error("Can't open existing substorage!");
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xResSubStorage1, "MediaType4", false, ElementModes.READ)) return false;
// open and check SubStorage2
XStorage xResSubStorage2 =
m_aTestHelper.openSubStorage(xResStorage, "SubStorage2", ElementModes.READ);
if (xResSubStorage2 == null) {
m_aTestHelper.Error("Can't open existing substorage!");
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xResSubStorage2, "MediaType5", false, ElementModes.READ)) return false;
// check all the result streams
if (!m_aTestHelper.checkStream(xResStorage, "SubStream1", "MediaType1", true, pBytes1))
return false;
if (!m_aTestHelper.checkStream(xResStorage, "BigSubStream1", "MediaType1", true, pBigBytes))
return false;
if (!m_aTestHelper.checkStream(xResStorage, "SubStream1_copy", "MediaType1", true, pBytes1))
return false;
if (!m_aTestHelper.checkStream(
xResStorage, "BigSubStream1_copy", "MediaType1", true, pBigBytes)) return false;
if (!m_aTestHelper.checkStream(xResSubStorage1, "SubStream1", "MediaType1", true, pBytes1))
return false;
if (!m_aTestHelper.checkStream(
xResSubStorage1, "BigSubStream1", "MediaType1", true, pBigBytes)) return false;
if (!m_aTestHelper.checkStream(xResSubStorage2, "SubStream2", "MediaType2", false, pBytes2))
return false;
if (!m_aTestHelper.checkStream(
xResSubStorage2, "BigSubStream2", "MediaType2", false, pBigBytes)) return false;
// the storage must be disposed before removing
if (!m_aTestHelper.disposeStorage(xResSubStorage2)) return false;
// remove element and check that it was removed completelly
if (!m_aTestHelper.removeElement(xResStorage, "SubStorage2")) return false;
try {
XNameAccess xResAccess =
(XNameAccess) UnoRuntime.queryInterface(XNameAccess.class, xResStorage);
if (xResAccess.hasByName("SubStorage2"))
m_aTestHelper.Error("SubStorage2 must be removed already!");
} catch (Exception e) {
m_aTestHelper.Error("Can't get access to root storage, exception: " + e);
return false;
}
try {
xResSubStorage2.isStreamElement("SubStream2");
m_aTestHelper.Error("SubStorage2 must be disposed already!");
return false;
} catch (com.sun.star.lang.DisposedException de) {
} catch (Exception e) {
m_aTestHelper.Error("Wrong exception in case of disposed storage, exception: " + e);
return false;
}
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xResStorage)) return false;
return true;
} catch (Exception e) {
m_aTestHelper.Error("Exception: " + e);
return false;
}
}
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;
}
}
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;
}
}
public boolean testForPath(String aStreamPrefix) {
try {
String aSubStream1Path = aStreamPrefix + "SubStream1";
String aSubStream2Path = aStreamPrefix + "SubStream2";
String aSubStream3Path = aStreamPrefix + "SubStream3";
String aSubStream4Path = aStreamPrefix + "SubStream4";
String sTempFileURL = m_aTestHelper.CreateTempFile(m_xMSF);
if (sTempFileURL == null || sTempFileURL == "") {
m_aTestHelper.Error("No valid temporary file was created!");
return false;
}
// create temporary storage based on a previously created temporary file
Object pArgs[] = new Object[2];
pArgs[0] = (Object) sTempFileURL;
pArgs[1] = new Integer(ElementModes.WRITE);
Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xTempFileStorage =
(XStorage) UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
if (xTempFileStorage == null) {
m_aTestHelper.Error("Can't create storage based on temporary file!");
return false;
}
// set the global password for the root storage
XEncryptionProtectedSource xTempStorageEncryption =
(XEncryptionProtectedSource)
UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xTempFileStorage);
if (xTempStorageEncryption == null) {
m_aTestHelper.Message(
"Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!");
return true;
}
String sPass1 = "12345";
String sPass2 = "54321";
try {
xTempStorageEncryption.setEncryptionPassword(sPass1);
} catch (Exception e) {
m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
return false;
}
byte pBytes1[] = {1, 1, 1, 1, 1};
byte pBytes2[] = {2, 2, 2, 2, 2};
// open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and commit
if (!m_aTestHelper.WBToSubstrOfEncrH(
xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1, true, true)) return false;
// open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and commit
if (!m_aTestHelper.WriteBytesToEncrStreamH(
xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2, sPass2, true))
return false;
// open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and commit
if (!m_aTestHelper.WriteBytesToEncrStreamH(
xTempFileStorage, aSubStream3Path, "MediaType3", false, pBytes2, sPass2, true))
return false;
// open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and dont commit
if (!m_aTestHelper.WBToSubstrOfEncrH(
xTempFileStorage, aSubStream4Path, "MediaType2", true, pBytes1, true, false))
return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempFileStorage, "MediaType3", true, ElementModes.WRITE)) return false;
// commit the root storage so the contents must be stored now
if (!m_aTestHelper.commitStorage(xTempFileStorage)) return false;
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xTempFileStorage)) return false;
// ================================================
// now reopen the storage,
// check all the written and copied information
// and change it
// ================================================
// the temporary file must not be locked any more after storage disposing
oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
xTempFileStorage = (XStorage) UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
if (xTempFileStorage == null) {
m_aTestHelper.Error("Can't create storage based on temporary file!");
return false;
}
// set the global password for the root storage
xTempStorageEncryption =
(XEncryptionProtectedSource)
UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xTempFileStorage);
if (xTempStorageEncryption == null) {
m_aTestHelper.Error("XEncryptionProtectedSource is supported, but can not be retrieved!");
return false;
}
try {
xTempStorageEncryption.setEncryptionPassword(sPass2);
} catch (Exception e) {
m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xTempFileStorage, "MediaType3", true, ElementModes.WRITE)) return false;
if (!m_aTestHelper.checkEncrStreamH(
xTempFileStorage, aSubStream1Path, "MediaType1", pBytes1, sPass1)) return false;
if (!m_aTestHelper.checkStreamH(
xTempFileStorage, aSubStream2Path, "MediaType2", true, pBytes2)) return false;
if (!m_aTestHelper.checkStreamH(
xTempFileStorage, aSubStream3Path, "MediaType3", true, pBytes2)) return false;
if (!m_aTestHelper.cantOpenEncrStreamH(
xTempFileStorage, aSubStream4Path, ElementModes.READ, sPass1)) return false;
// open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and commit
if (!m_aTestHelper.WriteBytesToEncrStreamH(
xTempFileStorage, aSubStream1Path, "MediaType4", true, pBytes2, sPass1, true))
return false;
// open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and don't commit
if (!m_aTestHelper.WriteBytesToStreamH(
xTempFileStorage, aSubStream2Path, "MediaType5", true, pBytes1, true)) return false;
// change the password of the existing stream
if (m_aTestHelper.ChangeStreamPassH(xTempFileStorage, aSubStream2Path, sPass2, sPass1, true)
!= 1) return false;
// open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
// write some bytes
// and don't commit
if (!m_aTestHelper.WriteBytesToStreamH(
xTempFileStorage, aSubStream3Path, "MediaType5", true, pBytes1, false)) return false;
// commit the root storage so the contents must be stored now
if (!m_aTestHelper.commitStorage(xTempFileStorage)) return false;
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xTempFileStorage)) return false;
// ================================================
// now reopen the storage,
// check all the written information
// ================================================
// the temporary file must not be locked any more after storage disposing
pArgs[1] = new Integer(ElementModes.READ);
Object oResultStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xResultStorage =
(XStorage) UnoRuntime.queryInterface(XStorage.class, oResultStorage);
if (xResultStorage == null) {
m_aTestHelper.Error("Can't reopen storage based on temporary file!");
return false;
}
// set the global password for the root storage
xTempStorageEncryption =
(XEncryptionProtectedSource)
UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xResultStorage);
if (xTempStorageEncryption == null) {
m_aTestHelper.Error("XEncryptionProtectedSource is supported, but can not be retrieved!");
return false;
}
try {
xTempStorageEncryption.setEncryptionPassword(sPass1);
} catch (Exception e) {
m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xResultStorage, "MediaType3", true, ElementModes.READ)) return false;
if (!m_aTestHelper.checkStreamH(xResultStorage, aSubStream1Path, "MediaType4", true, pBytes2))
return false;
if (!m_aTestHelper.checkStreamH(xResultStorage, aSubStream2Path, "MediaType5", true, pBytes1))
return false;
if (!m_aTestHelper.checkEncrStreamH(
xResultStorage, aSubStream3Path, "MediaType3", pBytes2, sPass2)) return false;
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xResultStorage)) return false;
return true;
} catch (Exception e) {
m_aTestHelper.Error("Exception: " + e);
return false;
}
}