コード例 #1
0
  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;
    }
  }
コード例 #2
0
  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;
    }
  }
コード例 #3
0
  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;
    }
  }
コード例 #4
0
  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;
    }
  }