Statement[] getMetadataFileStmts(XURI xBaseURI, String Path) throws Exception {
   XURI xManifest = URI.createNS(xContext, xBaseURI.getStringValue(), manifestPath);
   XURI xGraph = URI.createNS(xContext, xBaseURI.getStringValue(), Path);
   Statement xM_BaseHaspartGraph = new Statement(xBaseURI, pkg_hasPart, xGraph, xManifest);
   Statement xM_GraphTypeMetadata = new Statement(xGraph, rdf_type, pkg_MetadataFile, xManifest);
   return new Statement[] {xM_BaseHaspartGraph, xM_GraphTypeMetadata};
 }
 Statement[] getManifestStmts(XURI xBaseURI) throws Exception {
   XURI xManifest = URI.createNS(xContext, xBaseURI.getStringValue(), manifestPath);
   XURI xContent = URI.createNS(xContext, xBaseURI.getStringValue(), contentPath);
   XURI xStyles = URI.createNS(xContext, xBaseURI.getStringValue(), stylesPath);
   Statement xM_BaseTypeDoc = new Statement(xBaseURI, rdf_type, pkg_Document, xManifest);
   Statement xM_BaseHaspartContent = new Statement(xBaseURI, pkg_hasPart, xContent, xManifest);
   Statement xM_BaseHaspartStyles = new Statement(xBaseURI, pkg_hasPart, xStyles, xManifest);
   Statement xM_ContentTypeContent = new Statement(xContent, rdf_type, odf_ContentFile, xManifest);
   Statement xM_StylesTypeStyles = new Statement(xStyles, rdf_type, odf_StylesFile, xManifest);
   return new Statement[] {
     xM_BaseTypeDoc,
     xM_BaseHaspartContent,
     xM_BaseHaspartStyles,
     xM_ContentTypeContent,
     xM_StylesTypeStyles
   };
 }
  @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);
    }
  }