Esempio n. 1
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] = 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;
    }
  }
Esempio n. 2
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 = 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;
    }
  }