Exemple #1
0
 private void insertLinebreaks(long seed) {
   XText xText = m_xDoc.getText();
   java.util.Random rnd = new java.util.Random(seed);
   XTextCursor xCursor = m_xDoc.getText().createTextCursor();
   for (int i = 0; i < 30; i++) {
     xCursor.goRight((short) rnd.nextInt(300), false);
     XTextRange xCursorAsRange = UnoRuntime.queryInterface(XTextRange.class, xCursor);
     xText.insertControlCharacter(
         xCursorAsRange, com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, false);
   }
 }
  /**
   * Creating a TestEnvironment for the interfaces to be tested. Creates an instance of the service
   * <code>com.sun.star.text.Endnote</code>. Then created endnote is inserted to the text document,
   * and finally endnote settings are gotten from text document using <code>XEndnotesSupplier</code>
   * interface.
   */
  @Override
  public TestEnvironment createTestEnvironment(TestParameters Param, PrintWriter log)
      throws Exception {
    XEndnotesSupplier oInterface = null;
    XInterface oObj = null;
    XInterface oEndnote;

    log.println("Creating a test environment");
    XMultiServiceFactory msf = UnoRuntime.queryInterface(XMultiServiceFactory.class, xTextDoc);
    log.println("creating a endnote");
    oEndnote =
        UnoRuntime.queryInterface(
            XInterface.class, msf.createInstance("com.sun.star.text.Endnote"));

    XText oText = xTextDoc.getText();
    XTextCursor oCursor = oText.createTextCursor();

    log.println("inserting the footnote into text document");
    XTextContent xTC = UnoRuntime.queryInterface(XTextContent.class, oEndnote);
    oText.insertTextContent(oCursor, xTC, false);

    oInterface = UnoRuntime.queryInterface(XEndnotesSupplier.class, xTextDoc);
    oObj = oInterface.getEndnoteSettings();
    dbg.printPropertiesNames((XPropertySet) oObj);

    TestEnvironment tEnv = new TestEnvironment(oObj);
    return tEnv;
  }
Exemple #3
0
 private void insertRandomParts(long seed) {
   java.util.Random rnd = new java.util.Random(seed);
   XTextCursor xCursor = m_xDoc.getText().createTextCursor();
   for (int i = 0; i < 600; i++) {
     xCursor.goRight((short) rnd.nextInt(100), false);
     xCursor.setString(Long.toString(rnd.nextLong()));
   }
 }
Exemple #4
0
 private void deleteRandomParts(long seed) {
   java.util.Random rnd = new java.util.Random(seed);
   XTextCursor xCursor = m_xDoc.getText().createTextCursor();
   for (int i = 0; i < 600; i++) {
     xCursor.goRight((short) rnd.nextInt(100), false);
     xCursor.goRight((short) rnd.nextInt(20), true);
     xCursor.setString("");
   }
 }
Exemple #5
0
  private void insertBookmark(XTextCursor crsr, String name, String content)
      throws com.sun.star.uno.Exception {
    XMultiServiceFactory xDocFactory =
        UnoRuntime.queryInterface(XMultiServiceFactory.class, m_xDoc);

    Object xBookmark = xDocFactory.createInstance("com.sun.star.text.Bookmark");
    XTextContent xBookmarkAsTextContent = UnoRuntime.queryInterface(XTextContent.class, xBookmark);
    crsr.setString(content);
    XNamed xBookmarkAsNamed = UnoRuntime.queryInterface(XNamed.class, xBookmark);
    xBookmarkAsNamed.setName(name);
    m_xDoc.getText().insertTextContent(crsr, xBookmarkAsTextContent, true);
  }
  public void addTextArea(Object documentObj, String text, int x, int y, int width, int height)
      throws Exception {
    XTextDocument document = (XTextDocument) documentObj;
    XMultiServiceFactory factory = query(XMultiServiceFactory.class, document);

    XTextFrame xFrame = create(XTextFrame.class, factory, X_TEXTFRAME);

    setPositionAndSize(xFrame, x, y, width, height);

    XText xText = document.getText();
    xText.insertTextContent(xText.getEnd(), xFrame, false);

    appendText(xFrame.getText(), text);
  }
Exemple #7
0
 private void setupBookmarks() throws com.sun.star.uno.Exception {
   XText xText = m_xDoc.getText();
   UnoRuntime.queryInterface(XSimpleText.class, xText);
   for (int nPara = 0; nPara < 10; ++nPara) {
     for (int nBookmark = 0; nBookmark < 100; ++nBookmark) {
       insertBookmark(
           xText.createTextCursor(),
           "P" + nPara + "word" + nBookmark,
           "P" + nPara + "word" + nBookmark);
       XTextCursor xWordCursor = xText.createTextCursor();
       xWordCursor.setString(" ");
     }
     XTextCursor xParaCursor = xText.createTextCursor();
     XTextRange xParaCursorAsRange = UnoRuntime.queryInterface(XTextRange.class, xParaCursor);
     xText.insertControlCharacter(
         xParaCursorAsRange, com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, false);
   }
 }
  /**
   * Creating a Testenvironment for the interfaces to be tested. Creates an instance of the service
   * <code>com.sun.star.text.TextFrame</code>. Then inserts created text frame to the text, and
   * finally gets all frames of text document using <code>XTextFramesSupplier</code> interface.<br>
   */
  public synchronized TestEnvironment createTestEnvironment(TestParameters Param, PrintWriter log)
      throws StatusException {
    XInterface oObj = null;
    XTextFrame oFrame1 = null;
    XText oText = null;
    XTextCursor oCursor = null;
    XMultiServiceFactory oDocMSF = null;
    XTextFramesSupplier oInterface = null;

    log.println("creating a test environment");
    try {
      oDocMSF = UnoRuntime.queryInterface(XMultiServiceFactory.class, xTextDoc);
      Object oInt = oDocMSF.createInstance("com.sun.star.text.TextFrame");
      oFrame1 = UnoRuntime.queryInterface(XTextFrame.class, oInt);
    } catch (com.sun.star.uno.Exception e) {
      e.printStackTrace(log);
      throw new StatusException("Couldn't create instance of TextFrame", e);
    }

    oText = xTextDoc.getText();
    oCursor = oText.createTextCursor();

    try {
      oText.insertTextContent(oCursor, oFrame1, false);
    } catch (com.sun.star.lang.IllegalArgumentException e) {
      e.printStackTrace(log);
      throw new StatusException("Error: can't insert text content to text document", e);
    }

    oInterface = UnoRuntime.queryInterface(XTextFramesSupplier.class, xTextDoc);

    oObj = oInterface.getTextFrames();

    log.println("creating a new environment for Frame object");
    TestEnvironment tEnv = new TestEnvironment(oObj);

    return tEnv;
  } // finish method getTestEnvironment
  /**
   * Creating a Testenvironment for the interfaces to be tested. Creates an instance of the service
   * <code>com.sun.star.text.AutoTextContainer</code>, then selects the 'mytexts' group from the
   * given container using <code>XNameAccess</code> interface, and inserts some text entry to this
   * group. Then entry passed as test component.
   *
   * <p>Object relations created :
   *
   * <ul>
   *   <li><code>'XTEXTINFO'</code> for {@link ifc.text._XText} : creates tables 6x4
   *   <li><code>'TEXTDOC'</code> for {@link ifc.text._XAutoTextEntry} : text document
   * </ul>
   */
  protected synchronized TestEnvironment createTestEnvironment(
      TestParameters Param, PrintWriter log) {

    XAutoTextEntry oEntry = null;
    XAutoTextContainer oContainer;
    XInterface oObj = null;
    log.println("creating a test environment");
    try {
      XMultiServiceFactory myMSF = (XMultiServiceFactory) Param.getMSF();
      Object oInst = myMSF.createInstance("com.sun.star.text.AutoTextContainer");
      oContainer = UnoRuntime.queryInterface(XAutoTextContainer.class, oInst);
    } catch (com.sun.star.uno.Exception e) {
      e.printStackTrace(log);
      throw new StatusException("Couldn't create AutoTextContainer", e);
    }

    XNameAccess oContNames = UnoRuntime.queryInterface(XNameAccess.class, oContainer);

    String contNames[] = oContNames.getElementNames();
    for (int i = 0; i < contNames.length; i++) {
      log.println("ContainerNames[ " + i + "]: " + contNames[i]);
    }

    try {
      oObj =
          (XInterface)
              AnyConverter.toObject(new Type(XInterface.class), oContNames.getByName("mytexts"));
    } catch (com.sun.star.uno.Exception e) {
      e.printStackTrace(log);
      throw new StatusException("Couldn't get AutoTextGroup", e);
    }

    oGroup = UnoRuntime.queryInterface(XAutoTextGroup.class, oObj);
    String[] oENames = oGroup.getElementNames();
    for (int i = 0; i < oENames.length; i++) {
      log.println("AutoTextEntryNames[" + i + "]: " + oENames[i]);
    }

    XText oText = xTextDoc.getText();
    oText.insertString(oText.getStart(), "New AutoText", true);
    XTextRange oTextRange = oText;
    try {
      if (oGroup.hasByName("NewEntryName")) {
        oGroup.removeByName("NewEntryName");
        log.println("Element 'NewEntryName' exists, removing...");
      }
      log.println("Adding new element 'NewEntryName' to group...");
      oGroup.insertNewByName("NewEntryName", "NewEntryTitle", oTextRange);
      oEntry =
          (XAutoTextEntry)
              AnyConverter.toObject(
                  new Type(XAutoTextEntry.class), oGroup.getByName("NewEntryName"));
    } catch (com.sun.star.container.ElementExistException e) {
      e.printStackTrace(log);
    } catch (com.sun.star.container.NoSuchElementException e) {
      e.printStackTrace(log);
    } catch (com.sun.star.lang.WrappedTargetException e) {
      e.printStackTrace(log);
    } catch (com.sun.star.lang.IllegalArgumentException e) {
      e.printStackTrace(log);
    }

    oObj = oEntry;

    log.println("Trying to use XText as TextRange in the method applyTo");
    oEntry.applyTo(oTextRange);

    oTextRange = oText.createTextCursor();
    log.println("Trying to use XTextCursor as TextRange in the method applyTo");
    oEntry.applyTo(oTextRange);

    log.println("creating a new environment for AutoTextEntry object");
    TestEnvironment tEnv = new TestEnvironment(oObj);

    // adding relation for XText
    DefaultDsc tDsc =
        new DefaultDsc("com.sun.star.text.XTextContent", "com.sun.star.text.TextField.DateTime");
    log.println("    adding InstCreator object");
    tEnv.addObjRelation("XTEXTINFO", new InstCreator(xTextDoc, tDsc));

    log.println("adding TextDocument as mod relation to environment");
    tEnv.addObjRelation("TEXTDOC", xTextDoc);

    return tEnv;
  } // finish method getTestEnvironment
  /**
   * Called to create an instance of <code>TestEnvironment</code> with an object to test and related
   * objects. Creates a frame and inserts it into document. Obtains accessible object for the
   * inserted text frame.
   *
   * @param Param test parameters
   * @param log writer to log information while testing
   * @see TestEnvironment
   * @see #getTestEnvironment
   */
  protected TestEnvironment createTestEnvironment(TestParameters Param, PrintWriter log) {

    XInterface oObj = null;
    XTextFrame oFrame1 = null;
    XPropertySet oPropSet = null;
    XText oText = null;
    XTextCursor oCursor = null;

    // get a soffice factory object
    SOfficeFactory SOF = SOfficeFactory.getFactory((XMultiServiceFactory) Param.getMSF());
    // creating Frames
    log.println("creating Frames");
    try {
      oFrame1 = SOfficeFactory.createTextFrame(xTextDoc, 500, 500);
      oPropSet = UnoRuntime.queryInterface(XPropertySet.class, oFrame1);
      oPropSet.setPropertyValue("AnchorType", TextContentAnchorType.AS_CHARACTER);
      oText = xTextDoc.getText();
      oCursor = oText.createTextCursor();

      log.println("inserting Frame1");
      XTextContent the_content = UnoRuntime.queryInterface(XTextContent.class, oFrame1);
      oText.insertTextContent(oCursor, the_content, true);
    } catch (Exception e) {
      e.printStackTrace(log);
      throw new StatusException("Couldn't insert TextFrame", e);
    }

    XModel aModel = UnoRuntime.queryInterface(XModel.class, xTextDoc);

    AccessibilityTools at = new AccessibilityTools();

    XWindow xWindow =
        AccessibilityTools.getCurrentWindow((XMultiServiceFactory) Param.getMSF(), aModel);
    XAccessible xRoot = AccessibilityTools.getAccessibleObject(xWindow);

    oObj = AccessibilityTools.getAccessibleObjectForRole(xRoot, AccessibleRole.TEXT_FRAME);

    log.println("ImplementationName " + utils.getImplName(oObj));
    AccessibilityTools.printAccessibleTree(
        log, xRoot, Param.getBool(util.PropertyName.DEBUG_IS_ACTIVE));

    TestEnvironment tEnv = new TestEnvironment(oObj);

    XController xController = xTextDoc.getCurrentController();
    XViewSettingsSupplier xViewSetSup =
        UnoRuntime.queryInterface(XViewSettingsSupplier.class, xController);

    final XPropertySet PropSet = xViewSetSup.getViewSettings();

    tEnv.addObjRelation(
        "EventProducer",
        new ifc.accessibility._XAccessibleEventBroadcaster.EventProducer() {
          public void fireEvent() {
            try {
              // change zoom value to 15%
              PropSet.setPropertyValue("ZoomValue", new Short("15"));
              // and back to 100%
              PropSet.setPropertyValue("ZoomValue", new Short("100"));
            } catch (com.sun.star.lang.WrappedTargetException e) {

            } catch (com.sun.star.lang.IllegalArgumentException e) {

            } catch (com.sun.star.beans.PropertyVetoException e) {

            } catch (com.sun.star.beans.UnknownPropertyException e) {

            }
          }
        });

    return tEnv;
  }
  private XComponent loadRDFa(String file) throws Exception {
    XComponent xComp = null;

    System.out.println("Loading test document...");

    PropertyValue[] loadProps = new PropertyValue[1];
    loadProps[0] = new PropertyValue();
    loadProps[0].Name = "Hidden";
    loadProps[0].Value = true;

    xComp = util.DesktopTools.loadDoc(xMSF, file, loadProps);

    XRepositorySupplier xRepoSupplier = UnoRuntime.queryInterface(XRepositorySupplier.class, xComp);
    assertTrue("xRS null", null != xRepoSupplier);

    XDocumentRepository xDocRepository =
        UnoRuntime.queryInterface(XDocumentRepository.class, xRepoSupplier.getRDFRepository());
    assertTrue("xRep null", null != xDocRepository);

    XTextDocument xTextDoc = UnoRuntime.queryInterface(XTextDocument.class, xComp);

    XText xText = xTextDoc.getText();

    XEnumerationAccess xEA = UnoRuntime.queryInterface(XEnumerationAccess.class, xText);
    XEnumeration xEnum = xEA.createEnumeration();

    System.out.println("...done");

    System.out.println("Checking RDFa in loaded test document...");

    XMetadatable xPara;
    Pair<Statement[], Boolean> result;

    Statement x_FooBarLit1 = new Statement(foo, bar, mkLit("1"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 1", !result.Second && eq(result.First, new Statement[] {x_FooBarLit1}));

    Statement x_FooBarLit2 = new Statement(foo, bar, mkLit("2"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 2", !result.Second && eq(result.First, new Statement[] {x_FooBarLit2}));

    Statement x_BlankBarLit3 = new Statement(blank1, bar, mkLit("3"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 3", !result.Second && eq(result.First, new Statement[] {x_BlankBarLit3}));
    XBlankNode b3 = UnoRuntime.queryInterface(XBlankNode.class, result.First[0].Subject);

    Statement x_BlankBarLit4 = new Statement(blank2, bar, mkLit("4"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 4", !result.Second && eq(result.First, new Statement[] {x_BlankBarLit4}));
    XBlankNode b4 = UnoRuntime.queryInterface(XBlankNode.class, result.First[0].Subject);

    Statement x_BlankBarLit5 = new Statement(blank1, bar, mkLit("5"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 5", !result.Second && eq(result.First, new Statement[] {x_BlankBarLit5}));
    XBlankNode b5 = UnoRuntime.queryInterface(XBlankNode.class, result.First[0].Subject);

    assertTrue("RDFa: 3 != 4", !b3.getStringValue().equals(b4.getStringValue()));
    assertTrue("RDFa: 3 == 5", b3.getStringValue().equals(b5.getStringValue()));

    Statement x_FooBarLit6 = new Statement(foo, bar, mkLit("6"), null);
    Statement x_FooBazLit6 = new Statement(foo, baz, mkLit("6"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue(
        "RDFa: 6",
        !result.Second && eq(result.First, new Statement[] {x_FooBarLit6, x_FooBazLit6}));

    Statement x_FooBarLit7 = new Statement(foo, bar, mkLit("7"), null);
    Statement x_FooBazLit7 = new Statement(foo, baz, mkLit("7"), null);
    Statement x_FooFooLit7 = new Statement(foo, foo, mkLit("7"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue(
        "RDFa: 7",
        !result.Second
            && eq(result.First, new Statement[] {x_FooBarLit7, x_FooBazLit7, x_FooFooLit7}));

    XNode lit = mkLit("a fooish bar");
    XNode lit_type = mkLit("a fooish bar", bar);
    Statement x_FooBarLit = new Statement(foo, bar, lit, null);
    Statement x_FooBarLittype = new Statement(foo, bar, lit_type, null);

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 8", result.Second && eq(result.First, new Statement[] {x_FooBarLit}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 9", result.Second && eq(result.First, new Statement[] {x_FooBarLit}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 10", result.Second && eq(result.First, new Statement[] {x_FooBarLittype}));

    Statement x_FooBarLit11 = new Statement(foo, bar, mkLit("11", bar), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 11", !result.Second && eq(result.First, new Statement[] {x_FooBarLit11}));

    XURI xFile = URI.createNS(xContext, file, "/" + contentPath);
    Statement x_FileBarLit12 = new Statement(xFile, bar, mkLit("12"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 12", !result.Second && eq(result.First, new Statement[] {x_FileBarLit12}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 13", result.Second && eq(result.First, new Statement[] {x_FooBarLit}));

    new Statement(foo, rdfs_label, mkLit("14"), null);
    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue(
        "RDFa: 14",
        result.Second && eq(result.First, new Statement[] {/* x_FooLabelLit14 */ x_FooBarLit}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 15", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 16", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 17", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 18", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 19", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 20", eq(result.First, new Statement[] {}));

    xPara = UnoRuntime.queryInterface(XMetadatable.class, xEnum.nextElement());
    result = xDocRepository.getStatementRDFa(xPara);
    assertTrue("RDFa: 21", eq(result.First, new Statement[] {}));

    System.out.println("...done");

    return xComp;
  }
  @Test
  public void check() throws Exception {
    XComponent xComp = null;
    XComponent xComp2 = null;
    try {
      XEnumeration xStmtsEnum;
      XNamedGraph xManifest;

      System.out.println("Creating document with Repository...");

      // we cannot create a XDMA directly, we must create
      // a document and get it from there :(
      // create document
      PropertyValue[] loadProps = new PropertyValue[1];
      loadProps[0] = new PropertyValue();
      loadProps[0].Name = "Hidden";
      loadProps[0].Value = true;
      xComp = util.DesktopTools.openNewDoc(xMSF, "swriter", loadProps);
      XTextDocument xText = UnoRuntime.queryInterface(XTextDocument.class, xComp);

      XRepositorySupplier xRepoSupplier =
          UnoRuntime.queryInterface(XRepositorySupplier.class, xComp);
      assertNotNull("xRS null", xRepoSupplier);
      XDocumentMetadataAccess xDocMDAccess =
          UnoRuntime.queryInterface(XDocumentMetadataAccess.class, xRepoSupplier);
      assertNotNull("xDMA null", xDocMDAccess);
      xRep = xRepoSupplier.getRDFRepository();
      assertNotNull("xRep null", xRep);

      System.out.println("...done");

      System.out.println("Checking that new repository is initialized...");

      XURI xBaseURI = xDocMDAccess;
      String baseURI = xBaseURI.getStringValue();
      assertNotNull("new: baseURI", xBaseURI);
      assertTrue("new: baseURI", !xBaseURI.getStringValue().equals(""));

      assertTrue("new: # graphs", 1 == xRep.getGraphNames().length);
      XURI manifest = URI.createNS(xContext, xBaseURI.getStringValue(), manifestPath);
      xManifest = xRep.getGraph(manifest);
      assertTrue("new: manifest graph", null != xManifest);

      Statement[] manifestStmts = getManifestStmts(xBaseURI);
      xStmtsEnum = xRep.getStatements(null, null, null);
      assertTrue("new: manifest graph", eq(xStmtsEnum, manifestStmts));

      System.out.println("...done");

      System.out.println("Checking some invalid args...");

      String content = "behold, for I am the content.";
      new TestRange(content);

      try {
        xDocMDAccess.getElementByURI(null);
        fail("getElementByURI: null allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.getMetadataGraphsWithType(null);
        fail("getMetadataGraphsWithType: null URI allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("", new XURI[0]);
        fail("addMetadataFile: empty filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("/foo", new XURI[0]);
        fail("addMetadataFile: absolute filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("fo\"o", new XURI[0]);
        fail("addMetadataFile: invalid filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("../foo", new XURI[0]);
        fail("addMetadataFile: filename with .. allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("foo/../../bar", new XURI[0]);
        fail("addMetadataFile: filename with nest .. allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("foo/././bar", new XURI[0]);
        fail("addMetadataFile: filename with nest . allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("content.xml", new XURI[0]);
        fail("addMetadataFile: content.xml allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("styles.xml", new XURI[0]);
        fail("addMetadataFile: styles.xml allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("meta.xml", new XURI[0]);
        fail("addMetadataFile: meta.xml allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addMetadataFile("settings.xml", new XURI[0]);
        fail("addMetadataFile: settings.xml allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.importMetadataFile(FileFormat.RDF_XML, null, "foo", foo, new XURI[0]);
        fail("importMetadataFile: null stream allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }

      final String sEmptyRDF = TestDocument.getUrl("empty.rdf");
      try {
        XInputStream xFooIn = new StreamSimulator(sEmptyRDF, true, param);
        xDocMDAccess.importMetadataFile(FileFormat.RDF_XML, xFooIn, "", foo, new XURI[0]);
        fail("importMetadataFile: empty filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        XInputStream xFooIn = new StreamSimulator(sEmptyRDF, true, param);
        xDocMDAccess.importMetadataFile(FileFormat.RDF_XML, xFooIn, "meta.xml", foo, new XURI[0]);
        fail("importMetadataFile: meta.xml filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        XInputStream xFooIn = new StreamSimulator(sEmptyRDF, true, param);
        xDocMDAccess.importMetadataFile(FileFormat.RDF_XML, xFooIn, "foo", null, new XURI[0]);
        fail("importMetadataFile: null base URI allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        XInputStream xFooIn = new StreamSimulator(sEmptyRDF, true, param);
        xDocMDAccess.importMetadataFile(FileFormat.RDF_XML, xFooIn, "foo", rdf_type, new XURI[0]);
        fail("importMetadataFile: non-absolute base URI allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.removeMetadataFile(null);
        fail("removeMetadataFile: null URI allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addContentOrStylesFile("");
        fail("addContentOrStylesFile: empty filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addContentOrStylesFile("/content.xml");
        fail("addContentOrStylesFile: absolute filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.addContentOrStylesFile("foo.rdf");
        fail("addContentOrStylesFile: invalid filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.removeContentOrStylesFile("");
        fail("removeContentOrStylesFile: empty filename allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.loadMetadataFromStorage(null, foo, null);
        fail("loadMetadataFromStorage: null storage allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.storeMetadataToStorage(null /*, base*/);
        fail("storeMetadataToStorage: null storage allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.loadMetadataFromMedium(new PropertyValue[0]);
        fail("loadMetadataFromMedium: empty medium allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }
      try {
        xDocMDAccess.storeMetadataToMedium(new PropertyValue[0]);
        fail("storeMetadataToMedium: empty medium allowed");
      } catch (IllegalArgumentException e) {
        // ignore
      }

      System.out.println("...done");

      System.out.println("Checking file addition/removal...");

      xDocMDAccess.removeContentOrStylesFile(contentPath);
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue(
          "removeContentOrStylesFile (content)",
          eq(xStmtsEnum, new Statement[] {manifestStmts[0], manifestStmts[2], manifestStmts[4]}));

      xDocMDAccess.addContentOrStylesFile(contentPath);
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue("addContentOrStylesFile (content)", eq(xStmtsEnum, manifestStmts));

      xDocMDAccess.removeContentOrStylesFile(stylesPath);
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue(
          "removeContentOrStylesFile (styles)",
          eq(xStmtsEnum, new Statement[] {manifestStmts[0], manifestStmts[1], manifestStmts[3]}));

      xDocMDAccess.addContentOrStylesFile(stylesPath);
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue("addContentOrStylesFile (styles)", eq(xStmtsEnum, manifestStmts));

      XURI xFoo = URI.createNS(xContext, xBaseURI.getStringValue(), fooPath);
      Statement xM_BaseHaspartFoo = new Statement(xBaseURI, pkg_hasPart, xFoo, manifest);
      Statement xM_FooTypeMetadata = new Statement(xFoo, rdf_type, pkg_MetadataFile, manifest);
      Statement xM_FooTypeBar = new Statement(xFoo, rdf_type, bar, manifest);
      xDocMDAccess.addMetadataFile(fooPath, new XURI[] {bar});
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue(
          "addMetadataFile",
          eq(
              xStmtsEnum,
              merge(
                  manifestStmts,
                  new Statement[] {xM_BaseHaspartFoo, xM_FooTypeMetadata, xM_FooTypeBar})));

      XURI[] graphsBar = xDocMDAccess.getMetadataGraphsWithType(bar);
      assertTrue("getMetadataGraphsWithType", graphsBar.length == 1 && eq(graphsBar[0], xFoo));

      xDocMDAccess.removeMetadataFile(xFoo);
      xStmtsEnum = xManifest.getStatements(null, null, null);
      assertTrue("removeMetadataFile", eq(xStmtsEnum, manifestStmts));

      System.out.println("...done");

      System.out.println("Checking mapping...");

      XEnumerationAccess xTextEnum =
          UnoRuntime.queryInterface(XEnumerationAccess.class, xText.getText());
      Object o = xTextEnum.createEnumeration().nextElement();
      XMetadatable xMeta1 = UnoRuntime.queryInterface(XMetadatable.class, o);

      XMetadatable xMeta;
      xMeta = xDocMDAccess.getElementByURI(xMeta1);
      assertTrue("getElementByURI: null", null != xMeta);
      String XmlId = xMeta.getMetadataReference().Second;
      String XmlId1 = xMeta1.getMetadataReference().Second;
      assertTrue("getElementByURI: no xml id", !XmlId.equals(""));
      assertTrue("getElementByURI: different xml id", XmlId.equals(XmlId1));

      System.out.println("...done");

      System.out.println("Checking storing and loading...");

      XURI xFoobar = URI.createNS(xContext, xBaseURI.getStringValue(), fooBarPath);
      Statement[] metadataStmts = getMetadataFileStmts(xBaseURI, fooBarPath);
      xDocMDAccess.addMetadataFile(fooBarPath, new XURI[0]);
      xStmtsEnum = xRep.getStatements(null, null, null);
      assertTrue("addMetadataFile", eq(xStmtsEnum, merge(manifestStmts, metadataStmts)));

      Statement xFoobar_FooBarFoo = new Statement(foo, bar, foo, xFoobar);
      xRep.getGraph(xFoobar).addStatement(foo, bar, foo);
      xStmtsEnum = xRep.getStatements(null, null, null);
      assertTrue(
          "addStatement",
          eq(
              xStmtsEnum,
              merge(manifestStmts, merge(metadataStmts, new Statement[] {xFoobar_FooBarFoo}))));

      PropertyValue noMDNoContentFile = new PropertyValue();
      noMDNoContentFile.Name = "URL";
      noMDNoContentFile.Value = TestDocument.getUrl("CUSTOM.odt");
      PropertyValue noMDFile = new PropertyValue();
      noMDFile.Name = "URL";
      noMDFile.Value = TestDocument.getUrl("TEST.odt");
      PropertyValue file = new PropertyValue();
      file.Name = "URL";
      file.Value = tempDir + "TESTDMA.odt";
      PropertyValue mimetype = new PropertyValue();
      mimetype.Name = "MediaType";
      mimetype.Value = "application/vnd.oasis.opendocument.text";
      PropertyValue[] argsEmptyNoContent = {mimetype, noMDNoContentFile};
      PropertyValue[] argsEmpty = {mimetype, noMDFile};
      PropertyValue[] args = {mimetype, file};

      xStmtsEnum = xRep.getStatements(null, null, null);
      XURI[] graphs = xRep.getGraphNames();

      xDocMDAccess.storeMetadataToMedium(args);

      // this should re-init
      xDocMDAccess.loadMetadataFromMedium(argsEmptyNoContent);
      xRep = xRepoSupplier.getRDFRepository();
      assertTrue("xRep null", null != xRep);
      assertTrue("baseURI still tdoc?", !baseURI.equals(xDocMDAccess.getStringValue()));
      Statement[] manifestStmts2 = getManifestStmts(xDocMDAccess);
      xStmtsEnum = xRep.getStatements(null, null, null);
      // there is no content or styles file in here, so we have just
      // the package stmt
      assertTrue(
          "loadMetadataFromMedium (no metadata, no content)",
          eq(xStmtsEnum, new Statement[] {manifestStmts2[0]}));

      // this should re-init
      xDocMDAccess.loadMetadataFromMedium(argsEmpty);
      xRep = xRepoSupplier.getRDFRepository();
      assertTrue("xRep null", null != xRep);
      assertTrue("baseURI still tdoc?", !baseURI.equals(xDocMDAccess.getStringValue()));
      Statement[] manifestStmts3 = getManifestStmts(xDocMDAccess);

      xStmtsEnum = xRep.getStatements(null, null, null);
      assertTrue("loadMetadataFromMedium (no metadata)", eq(xStmtsEnum, manifestStmts3));

      xDocMDAccess.loadMetadataFromMedium(args);
      xRep = xRepoSupplier.getRDFRepository();
      assertTrue("xRep null", null != xRep);
      Statement[] manifestStmts4 = getManifestStmts(xDocMDAccess);
      Statement[] metadataStmts4 = getMetadataFileStmts(xDocMDAccess, fooBarPath);

      xStmtsEnum = xRep.getStatements(null, null, null);
      assertTrue("some graph(s) not reloaded", graphs.length == xRep.getGraphNames().length);

      XURI xFoobar4 = URI.createNS(xContext, xDocMDAccess.getStringValue(), fooBarPath);
      Statement xFoobar_FooBarFoo4 = new Statement(foo, bar, foo, xFoobar4);
      assertTrue(
          "loadMetadataFromMedium (re-load)",
          eq(
              xStmtsEnum,
              merge(manifestStmts4, merge(metadataStmts4, new Statement[] {xFoobar_FooBarFoo4}))));

      System.out.println("...done");

      System.out.println("Checking storing and loading via model...");

      String f = tempDir + "TESTPARA.odt";

      XStorable xStor = UnoRuntime.queryInterface(XStorable.class, xRepoSupplier);

      xStor.storeToURL(f, new PropertyValue[0]);

      xComp2 = util.DesktopTools.loadDoc(xMSF, f, loadProps);

      XDocumentMetadataAccess xDMA2 =
          UnoRuntime.queryInterface(XDocumentMetadataAccess.class, xComp2);
      assertTrue("xDMA2 null", null != xDMA2);

      XRepositorySupplier xRS2 = UnoRuntime.queryInterface(XRepositorySupplier.class, xComp2);
      assertTrue("xRS2 null", null != xRS2);

      XRepository xRep2 = xRS2.getRDFRepository();
      assertTrue("xRep2 null", null != xRep2);

      Statement[] manifestStmts5 = getManifestStmts(xDMA2);
      Statement[] metadataStmts5 = getMetadataFileStmts(xDMA2, fooBarPath);
      XURI xFoobar5 = URI.createNS(xContext, xDMA2.getStringValue(), fooBarPath);
      Statement xFoobar_FooBarFoo5 = new Statement(foo, bar, foo, xFoobar5);
      xStmtsEnum = xRep.getStatements(null, null, null);
      XEnumeration xStmtsEnum2 = xRep2.getStatements(null, null, null);
      assertTrue(
          "load: repository differs",
          eq(
              xStmtsEnum2,
              merge(manifestStmts5, merge(metadataStmts5, new Statement[] {xFoobar_FooBarFoo5}))));

      System.out.println("...done");

    } finally {
      close(xComp);
      close(xComp2);
    }
  }