Пример #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;
    }
  }