/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
package complex.sfx2;
// import complexlib.ComplexTestCase;
import com.sun.star.beans.Pair;
import com.sun.star.rdf.Literal;
import com.sun.star.rdf.XLiteral;
import com.sun.star.rdf.XNamedGraph;
import com.sun.star.rdf.BlankNode;
import com.sun.star.rdf.XQuerySelectResult;
import com.sun.star.rdf.XNode;
import com.sun.star.rdf.XDocumentRepository;
import com.sun.star.rdf.XMetadatable;
import com.sun.star.rdf.Statement;
import com.sun.star.rdf.FileFormat;
import com.sun.star.rdf.URIs;
import com.sun.star.rdf.URI;
import com.sun.star.rdf.XDocumentMetadataAccess;
import com.sun.star.rdf.XRepositorySupplier;
import com.sun.star.rdf.XRepository;
import com.sun.star.rdf.XBlankNode;
import com.sun.star.rdf.XURI;
import helper.StreamSimulator;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.lang.WrappedTargetException;
import com.sun.star.lang.WrappedTargetRuntimeException;
import com.sun.star.beans.XPropertySet;
import com.sun.star.beans.PropertyValue;
import com.sun.star.beans.StringPair;
import com.sun.star.container.XEnumerationAccess;
import com.sun.star.container.XEnumeration;
import com.sun.star.io.XInputStream;
import com.sun.star.util.XCloseable;
import com.sun.star.frame.XStorable;
import com.sun.star.text.XTextDocument;
import com.sun.star.text.XTextRange;
import com.sun.star.text.XText;
import complex.sfx2.tools.TestDocument;
import lib.TestParameters;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.openoffice.test.OfficeConnection;
import static org.junit.Assert.*;
/**
* Test case for interface com.sun.star.rdf.XDocumentMetadataAccess
* Currently, this service is implemented in
* sfx2/source/doc/DocumentMetadataAccess.cxx
*
* Actually, this is not a service, so we need to create a document and
* go from there...
*
* @author mst
*/
public class DocumentMetadataAccess
{
XMultiServiceFactory xMSF;
XComponentContext xContext;
String tempDir;
String nsRDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
String nsRDFS = "http://www.w3.org/2000/01/rdf-schema#";
String nsPkg="http://docs.oasis-open.org/opendocument/meta/package/common#";
String nsODF ="http://docs.oasis-open.org/opendocument/meta/package/odf#";
XURI foo;
XURI bar;
XURI baz;
static XURI rdf_type;
static XURI rdfs_label;
static XURI pkg_Document;
static XURI pkg_hasPart;
static XURI pkg_MetadataFile;
static XURI odf_ContentFile;
static XURI odf_StylesFile;
static XURI odf_Element;
static XBlankNode blank1;
static XBlankNode blank2;
static XBlankNode blank3;
static XBlankNode blank4;
static String manifestPath = "manifest.rdf";
static String contentPath = "content.xml";
static String stylesPath = "styles.xml";
static String fooPath = "foo.rdf";
static String fooBarPath = "meta/foo/bar.rdf";
XRepository xRep;
XRepositorySupplier xRS;
XDocumentMetadataAccess xDMA;
// public String[] getTestMethodNames ()
// {
// return new String[] { "check", "checkRDFa" };
// }
/**
* The test parameters
*/
private static TestParameters param = null;
@Before public void before()
{
try {
xMSF = getMSF();
param = new TestParameters();
param.put("ServiceFactory", xMSF); // important for param.getMSF()
assertNotNull("could not create MultiServiceFactory.", xMSF);
XPropertySet xPropertySet = UnoRuntime.queryInterface(XPropertySet.class, xMSF);
Object defaultCtx = xPropertySet.getPropertyValue("DefaultContext");
xContext = UnoRuntime.queryInterface(XComponentContext.class, defaultCtx);
assertNotNull("could not get component context.", xContext);
tempDir = util.utils.getOfficeTemp/*Dir*/(xMSF);
System.out.println("tempdir: " + tempDir);
foo = URI.create(xContext, "uri:foo");
assertNotNull("foo", foo);
bar = URI.create(xContext, "uri:bar");
assertNotNull("bar", bar);
baz = URI.create(xContext, "uri:baz");
assertNotNull("baz", baz);
blank1 = BlankNode.create(xContext, "_:1");
assertNotNull("blank1", blank1);
blank2 = BlankNode.create(xContext, "_:2");
assertNotNull("blank2", blank2);
blank3 = BlankNode.create(xContext, "_:3");
assertNotNull("blank3", blank3);
blank4 = BlankNode.create(xContext, "_:4");
assertNotNull("blank4", blank4);
rdf_type = URI.createKnown(xContext, URIs.RDF_TYPE);
assertNotNull("rdf_type", rdf_type);
rdfs_label = URI.createKnown(xContext, URIs.RDFS_LABEL);
assertNotNull("rdfs_label", rdfs_label);
pkg_Document = URI.createKnown(xContext, URIs.PKG_DOCUMENT);
assertNotNull("pkg_Document", pkg_Document);
pkg_hasPart = URI.createKnown(xContext, URIs.PKG_HASPART);
assertNotNull("pkg_hasPart", pkg_hasPart);
pkg_MetadataFile = URI.createKnown(xContext, URIs.PKG_METADATAFILE);
assertNotNull("pkg_MetadataFile", pkg_MetadataFile);
odf_ContentFile = URI.createKnown(xContext, URIs.ODF_CONTENTFILE);
assertNotNull("odf_ContentFile", odf_ContentFile);
odf_StylesFile = URI.createKnown(xContext, URIs.ODF_STYLESFILE);
assertNotNull("odf_StylesFile", odf_StylesFile);
odf_Element = URI.createKnown(xContext, URIs.ODF_ELEMENT);
assertNotNull("odf_Element", odf_Element);
} catch (Exception e) {
report(e);
}
}
@After public void after()
{
xRep = null;
xRS = null;
xDMA = null;
}
@Test public void check()
{
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 = (XURI) 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.";
XTextRange xTR = new TestRange(content);
XMetadatable xM = (XMetadatable) xTR;
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);
XURI uri;
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 baseURL = new PropertyValue();
baseURL.Name = "DocumentBaseURL";
baseURL.Value = tempDir + "TMP.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((XURI) 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((XURI) 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((XURI) xDocMDAccess);
Statement[] metadataStmts4 = getMetadataFileStmts((XURI) 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((XURI) xDMA2);
Statement[] metadataStmts5 = getMetadataFileStmts((XURI) 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");
} catch (Exception e) {
report(e);
} finally {
close(xComp);
close(xComp2);
}
}
@Test public void checkRDFa()
{
XComponent xComp = null;
try {
final String file = TestDocument.getUrl("TESTRDFA.odt");
xComp = loadRDFa(file);
if (xComp != null)
{
final String sNewFile = tempDir + "TESTRDFA.odt";
storeRDFa(xComp, sNewFile);
close(xComp);
xComp = loadRDFa(sNewFile);
}
} finally {
close(xComp);
}
}
private void storeRDFa(XComponent xComp, String file)
{
try {
System.out.println("Storing test document...");
XStorable xStor = UnoRuntime.queryInterface(XStorable.class, xComp);
xStor.storeToURL(file, new PropertyValue[0]);
System.out.println("...done");
} catch (Exception e) {
report(e);
}
}
private XComponent loadRDFa(String file)
{
XComponent xComp = null;
try {
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
}));
Statement x_FooLabelLit14 =
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");
} catch (Exception e) {
report(e);
close(xComp);
}
return xComp;
}
// utilities -------------------------------------------------------------
public void report2(Exception e)
{
if (e instanceof WrappedTargetException)
{
System.out.println("Cause:");
Exception cause = (Exception)
(((WrappedTargetException)e).TargetException);
System.out.println(cause.toString());
report2(cause);
} else if (e instanceof WrappedTargetRuntimeException) {
System.out.println("Cause:");
Exception cause = (Exception)
(((WrappedTargetRuntimeException)e).TargetException);
System.out.println(cause.toString());
report2(cause);
}
}
public void report(Exception e) {
System.out.println("Exception occurred:");
e.printStackTrace(System.out);
report2(e);
fail();
}
static void close(XComponent i_comp)
{
try {
XCloseable xClos = UnoRuntime.queryInterface(XCloseable.class, i_comp);
if (xClos != null)
{
xClos.close(true);
}
} catch (Exception e) {
}
}
XLiteral mkLit(String i_content)
{
return Literal.create(xContext, i_content);
}
XLiteral mkLit(String i_content, XURI i_uri)
{
return Literal.createWithType(xContext, i_content, i_uri);
}
static Statement[] merge(Statement[] i_A1, Statement[] i_A2)
{
// bah, java sucks...
Statement[] ret = new Statement[i_A1.length + i_A2.length];
for (int i = 0; i < i_A1.length; ++i) {
ret[i] = i_A1[i];
}
for (int i = 0; i < i_A2.length; ++i) {
ret[i+i_A1.length] = i_A2[i];
}
return ret;
}
public static String toS(XNode n) {
if (null == n)
{
return "< null >";
}
return n.getStringValue();
}
static boolean isBlank(XNode i_node)
{
XBlankNode blank = UnoRuntime.queryInterface(XBlankNode.class, i_node);
return blank != null;
}
/*
static class Statement implements XStatement
{
XResource m_Subject;
XResource m_Predicate;
XNode m_Object;
XURI m_Graph;
Statement(XResource i_Subject, XResource i_Predicate, XNode i_Object,
XURI i_Graph)
{
m_Subject = i_Subject;
m_Predicate = i_Predicate;
m_Object = i_Object;
m_Graph = i_Graph;
}
public XResource getSubject() { return m_Subject; }
public XResource getPredicate() { return m_Predicate; }
public XNode getObject() { return m_Object; }
public XURI getGraph() { return m_Graph; }
}
*/
static Statement[] toSeq(XEnumeration i_Enum) throws Exception
{
java.util.Collection c = new java.util.Vector();
while (i_Enum.hasMoreElements()) {
Statement s = (Statement) i_Enum.nextElement();
//System.out.println("toSeq: " + s.getSubject().getStringValue() + " " + s.getPredicate().getStringValue() + " " + s.getObject().getStringValue() + ".");
c.add(s);
}
// return (Statement[]) c.toArray();
// java sucks
Object[] arr = c.toArray();
Statement[] ret = new Statement[arr.length];
for (int i = 0; i < arr.length; ++i) {
ret[i] = (Statement) arr[i];
}
return ret;
}
static XNode[][] toSeqs(XEnumeration i_Enum) throws Exception
{
java.util.Collection c = new java.util.Vector();
while (i_Enum.hasMoreElements()) {
XNode[] s = (XNode[]) i_Enum.nextElement();
c.add(s);
}
// return (XNode[][]) c.toArray();
Object[] arr = c.toArray();
XNode[][] ret = new XNode[arr.length][];
for (int i = 0; i < arr.length; ++i) {
ret[i] = (XNode[]) arr[i];
}
return ret;
}
static class BindingComp implements java.util.Comparator
{
public int compare(Object i_Left, Object i_Right)
{
XNode[] left = (XNode[]) i_Left;
XNode[] right = (XNode[]) i_Right;
if (left.length != right.length)
{
throw new RuntimeException();
}
for (int i = 0; i < left.length; ++i) {
int eq = (left[i].getStringValue().compareTo(
right[i].getStringValue()));
if (eq != 0)
{
return eq;
}
}
return 0;
}
}
static class StmtComp implements java.util.Comparator
{
public int compare(Object i_Left, Object i_Right)
{
int eq;
Statement left = (Statement) i_Left;
Statement right = (Statement) i_Right;
if ((eq = cmp(left.Graph, right.Graph )) != 0) return eq;
if ((eq = cmp(left.Subject, right.Subject )) != 0) return eq;
if ((eq = cmp(left.Predicate, right.Predicate)) != 0) return eq;
if ((eq = cmp(left.Object, right.Object )) != 0) return eq;
return 0;
}
public int cmp(XNode i_Left, XNode i_Right)
{
if (isBlank(i_Left)) {
return isBlank(i_Right) ? 0 : 1;
} else {
if (isBlank(i_Right)) {
return -1;
} else {
return toS(i_Left).compareTo(toS(i_Right));
}
}
}
}
static boolean eq(Statement i_Left, Statement i_Right)
{
XURI lG = i_Left.Graph;
XURI rG = i_Right.Graph;
if (!eq(lG, rG)) {
System.out.println("Graphs differ: " + toS(lG) + " != " + toS(rG));
return false;
}
if (!eq(i_Left.Subject, i_Right.Subject)) {
System.out.println("Subjects differ: " +
i_Left.Subject.getStringValue() + " != " +
i_Right.Subject.getStringValue());
return false;
}
if (!eq(i_Left.Predicate, i_Right.Predicate)) {
System.out.println("Predicates differ: " +
i_Left.Predicate.getStringValue() + " != " +
i_Right.Predicate.getStringValue());
return false;
}
if (!eq(i_Left.Object, i_Right.Object)) {
System.out.println("Objects differ: " +
i_Left.Object.getStringValue() + " != " +
i_Right.Object.getStringValue());
return false;
}
return true;
}
static boolean eq(Statement[] i_Result, Statement[] i_Expected)
{
if (i_Result.length != i_Expected.length) {
System.out.println("eq: different lengths: " + i_Result.length + " " +
i_Expected.length);
return false;
}
Statement[] expected = (Statement[])
java.util.Arrays.asList(i_Expected).toArray();
java.util.Arrays.sort(i_Result, new StmtComp());
java.util.Arrays.sort(expected, new StmtComp());
for (int i = 0; i < expected.length; ++i)
{
// This is better for debug!
final Statement a = i_Result[i];
final Statement b = expected[i];
final boolean cond = eq(a, b);
if (!cond) return false;
}
return true;
}
static boolean eq(XEnumeration i_Enum, Statement[] i_Expected)
throws Exception
{
Statement[] current = toSeq(i_Enum);
return eq(current, i_Expected);
}
static boolean eq(XNode i_Left, XNode i_Right)
{
if (i_Left == null) {
return (i_Right == null);
} else {
return (i_Right != null) &&
(i_Left.getStringValue().equals(i_Right.getStringValue())
// FIXME: hack: blank nodes considered equal
|| (isBlank(i_Left) && isBlank(i_Right)));
}
}
static boolean eq(XQuerySelectResult i_Result,
String[] i_Vars, XNode[][] i_Bindings) throws Exception
{
String[] vars = i_Result.getBindingNames();
XEnumeration iter = (XEnumeration) i_Result;
XNode[][] bindings = toSeqs(iter);
if (vars.length != i_Vars.length) {
System.out.println("var lengths differ");
return false;
}
if (bindings.length != i_Bindings.length) {
System.out.println("binding lengths differ: " + i_Bindings.length +
" vs " + bindings.length );
return false;
}
java.util.Arrays.sort(bindings, new BindingComp());
java.util.Arrays.sort(i_Bindings, new BindingComp());
for (int i = 0; i < i_Bindings.length; ++i) {
if (i_Bindings[i].length != i_Vars.length) {
System.out.println("TEST ERROR!");
throw new Exception();
}
if (bindings[i].length != i_Vars.length) {
System.out.println("binding length and var length differ");
return false;
}
for (int j = 0; j < i_Vars.length; ++j) {
if (!eq(bindings[i][j], i_Bindings[i][j])) {
System.out.println("bindings differ: " +
toS(bindings[i][j]) + " != " + toS(i_Bindings[i][j]));
return false;
}
}
}
for (int i = 0; i < i_Vars.length; ++i) {
if (!vars[i].equals(i_Vars[i])) {
System.out.println("variable names differ: " +
vars[i] + " != " + i_Vars[i]);
return false;
}
}
return true;
}
static boolean eq(StringPair i_Left, StringPair i_Right)
{
return ((i_Left.First).equals(i_Right.First)) &&
((i_Left.Second).equals(i_Right.Second));
}
static String mkNamespace(String i_prefix, String i_namespace)
{
return "PREFIX " + i_prefix + ": <" + i_namespace + ">\n";
}
static String mkNss()
{
String namespaces = mkNamespace("rdf",
"http://www.w3.org/1999/02/22-rdf-syntax-ns#");
namespaces += mkNamespace("pkg",
"http://docs.oasis-open.org/opendocument/meta/package/common#");
namespaces += mkNamespace("odf",
"http://docs.oasis-open.org/opendocument/meta/package/odf#");
return namespaces;
}
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
};
}
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 };
}
class TestRange implements XTextRange, XMetadatable, XServiceInfo
{
String m_Stream;
String m_XmlId;
String m_Text;
TestRange(String i_Str) { m_Text = i_Str; }
public String getStringValue() { return ""; }
public String getNamespace() { return ""; }
public String getLocalName() { return ""; }
public StringPair getMetadataReference()
{
return new StringPair(m_Stream, m_XmlId);
}
public void setMetadataReference(StringPair i_Ref)
throws IllegalArgumentException
{
m_Stream = i_Ref.First;
m_XmlId = i_Ref.Second;
}
public void ensureMetadataReference()
{
m_Stream = "content.xml";
m_XmlId = "42";
}
public String getImplementationName() { return null; }
public String[] getSupportedServiceNames() { return null; }
public boolean supportsService(String i_Svc)
{
return i_Svc.equals("com.sun.star.text.Paragraph");
}
public XText getText() { return null; }
public XTextRange getStart() { return null; }
public XTextRange getEnd() { return null; }
public String getString() { return m_Text; }
public void setString(String i_Str) { m_Text = i_Str; }
}
private XMultiServiceFactory getMSF()
{
final XMultiServiceFactory xMSF1 = UnoRuntime.queryInterface(XMultiServiceFactory.class, connection.getComponentContext().getServiceManager());
return xMSF1;
}
// setup and close connections
@BeforeClass public static void setUpConnection() throws Exception {
System.out.println( "------------------------------------------------------------" );
System.out.println( "starting class: " + DocumentMetadataAccess.class.getName() );
System.out.println( "------------------------------------------------------------" );
connection.setUp();
}
@AfterClass public static void tearDownConnection()
throws InterruptedException, com.sun.star.uno.Exception
{
System.out.println( "------------------------------------------------------------" );
System.out.println( "finishing class: " + DocumentMetadataAccess.class.getName() );
System.out.println( "------------------------------------------------------------" );
connection.tearDown();
}
private static final OfficeConnection connection = new OfficeConnection();
}