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] = xTempFileStream;
pArgs[1] = new Integer(ElementModes.WRITE);
Object oTempStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xTempStorage = UnoRuntime.queryInterface(XStorage.class, oTempStorage);
if (xTempStorage == null) {
m_aTestHelper.Error("Can't create temporary storage representation!");
return false;
}
// open a new substorage
XStorage xTempSubStorage =
m_aTestHelper.openSubStorage(xTempStorage, "SubStorage1", ElementModes.WRITE);
if (xTempSubStorage == null) {
m_aTestHelper.Error("Can't create substorage!");
return false;
}
byte pBytes1[] = {1, 1, 1, 1, 1};
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToSubstream(
xTempSubStorage, "SubStream1", "MediaType1", true, pBytes1)) return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempStorage, "MediaType2", true, ElementModes.WRITE)) return false;
// set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
// set correctly
if (!m_aTestHelper.setStorageTypeAndCheckProps(
xTempSubStorage, "MediaType3", false, ElementModes.WRITE)) return false;
// commit substorage first
if (!m_aTestHelper.commitStorage(xTempSubStorage)) return false;
// commit the root storage so the contents must be stored now
if (!m_aTestHelper.commitStorage(xTempStorage)) return false;
// dispose used storage to free resources
// the substorage dispose will be triggered by this call
if (!m_aTestHelper.disposeStorage(xTempStorage)) return false;
// now check all the written information
// close the output part of the temporary stream
// the output part must present since we already wrote to the stream
if (!m_aTestHelper.closeOutput(xTempFileStream)) return false;
XInputStream xTempInStream = m_aTestHelper.getInputStream(xTempFileStream);
if (xTempInStream == null) return false;
// open input stream
// since no mode is provided the result storage must be opened readonly
Object pOneArg[] = new Object[1];
pOneArg[0] = xTempInStream;
Object oResultStorage = m_xStorageFactory.createInstanceWithArguments(pOneArg);
XStorage xResultStorage = UnoRuntime.queryInterface(XStorage.class, oResultStorage);
if (xResultStorage == null) {
m_aTestHelper.Error("Can't open storage based on input stream!");
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xResultStorage, "MediaType2", true, ElementModes.READ)) return false;
// open existing substorage
XStorage xResultSubStorage =
m_aTestHelper.openSubStorage(xResultStorage, "SubStorage1", ElementModes.READ);
if (xResultSubStorage == null) {
m_aTestHelper.Error("Can't open existing substorage!");
return false;
}
if (!m_aTestHelper.checkStorageProperties(
xResultSubStorage, "MediaType3", false, ElementModes.READ)) return false;
if (!m_aTestHelper.checkStream(xResultSubStorage, "SubStream1", "MediaType1", pBytes1))
return false;
return true;
} catch (Exception e) {
m_aTestHelper.Error("Exception: " + e);
return false;
}
}
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 = UnoRuntime.queryInterface(XStorage.class, oTempStorage);
if (xTempStorage == null) {
m_aTestHelper.Error("Can't create temporary storage representation!");
return false;
}
byte pBytes1[] = {1, 1, 1, 1, 1};
byte pPass1[] = {1, 2, 3, 4, 5};
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToEncrSubstream(
xTempStorage, "SubStream1", "MediaType1", true, pBytes1, pPass1)) return false;
byte pBytes2[] = {2, 2, 2, 2, 2};
byte pPass2[] = {5, 4, 3, 2, 1};
// open a new substream, set "MediaType" and "Compressed" properties to it and write some
// bytes
if (!m_aTestHelper.WriteBytesToEncrSubstream(
xTempStorage, "SubStream2", "MediaType2", false, pBytes2, pPass2)) return false;
// create temporary storage based on a previously created temporary file
Object pArgs[] = new Object[2];
pArgs[0] = sTempFileURL;
pArgs[1] = new Integer(ElementModes.WRITE);
Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xTempFileStorage = UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
if (xTempFileStorage == null) {
m_aTestHelper.Error("Can't create storage based on temporary file!");
return false;
}
// copy xTempStorage to xTempFileStorage
// xTempFileStorage will be automatically commited
if (!m_aTestHelper.copyStorage(xTempStorage, xTempFileStorage)) return false;
// dispose used storages to free resources
if (!m_aTestHelper.disposeStorage(xTempStorage)
|| !m_aTestHelper.disposeStorage(xTempFileStorage)) return false;
// now check all the written and copied information
// the temporary file must not be locked any more after storage disposing
pArgs[1] = new Integer(ElementModes.READWRITE);
Object oResultStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
XStorage xResultStorage = UnoRuntime.queryInterface(XStorage.class, oResultStorage);
if (xResultStorage == null) {
m_aTestHelper.Error("Can't reopen storage based on temporary file!");
return false;
}
Object o2CopyStorage = m_xStorageFactory.createInstance();
XStorage x2CopyStorage = UnoRuntime.queryInterface(XStorage.class, o2CopyStorage);
if (x2CopyStorage == null) {
m_aTestHelper.Error("Can't create temporary storage representation!");
return false;
}
if (!m_aTestHelper.copyStorage(xResultStorage, x2CopyStorage)) return false;
if (!m_aTestHelper.checkEncrStream(
xResultStorage, "SubStream1", "MediaType1", pBytes1, pPass1)) return false;
if (!m_aTestHelper.checkEncrStream(
xResultStorage, "SubStream2", "MediaType2", pBytes2, pPass2)) return false;
if (!m_aTestHelper.checkEncrStream(
x2CopyStorage, "SubStream1", "MediaType1", pBytes1, pPass1)) return false;
if (!m_aTestHelper.checkEncrStream(
x2CopyStorage, "SubStream2", "MediaType2", pBytes2, pPass2)) 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;
}
}