/**************************************************************
*
* 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.tdoc;
import com.sun.star.beans.XPropertiesChangeNotifier;
import com.sun.star.beans.XPropertyContainer;
import com.sun.star.beans.XPropertySetInfoChangeNotifier;
import com.sun.star.container.XChild;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.lang.XServiceInfo;
import com.sun.star.lang.XTypeProvider;
import com.sun.star.text.XTextDocument;
import com.sun.star.ucb.XCommandInfoChangeNotifier;
import com.sun.star.ucb.XCommandProcessor;
import com.sun.star.ucb.XContent;
import com.sun.star.ucb.XContentIdentifier;
import com.sun.star.ucb.XContentIdentifierFactory;
import com.sun.star.ucb.XContentProvider;
import com.sun.star.uno.UnoRuntime;
import util.WriterTools;
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.*;
/**
* Check the TransientDocumentsContentProvider (TDOC). Three documents are
* loaded. Then every possible TDCP content type is instantiated and its
* interfaces are tested.<br>
* Important: opened documents are numbered in the order they are opened and
* numbers are not reused. This test will work only, if you start a new office
* with an accept parameter (writer is initially opened). Otherwise loaded
* documents are not found.
*/
public class CheckContentProvider {
private final String testDocuments[] = new String[]{"filter.sxw", "chinese.sxw", "Iterator.sxw"};
private final int countDocs = testDocuments.length;
private XMultiServiceFactory xMSF = null;
private XTextDocument[] xTextDoc = null;
private XContent xContent = null;
/**
* The test methods: the test methods have to be executed in a specified
* order. This order is:
* <ol>
* <li>"checkTDOCRoot"</li>
* <li>"checkTDOCRootInterfaces"</li>
* <li>"checkTDOCDocument"</li>
* <li>"checkTDOCDocumentInterfaces"</li>
* <li>"checkTDOCFolder"</li>
* <li>"checkTDOCFolderInterfaces"</li>
* <li>"checkTDOCStream"</li>
* <li>"checkTDOCStreamInterfaces"</li>
* </ol>
* Important is, that the test of the element comes first, then the test of
* its interfaces.
**/
// public String[] getTestMethodNames() {
// return new String[]{"checkTDOCRoot",
// "checkTDOCRootInterfaces",
// "checkTDOCDocument",
// "checkTDOCDocumentInterfaces",
// "checkTDOCFolder",
// "checkTDOCFolderInterfaces",
// "checkTDOCStream",
// "checkTDOCStreamInterfaces",
// };
// }
/**
* Open some documents before the test
*/
@Before public void before() {
xMSF = getMSF();
xTextDoc = new XTextDocument[countDocs];
System.out.println("Open some new documents.");
for (int i=0; i<countDocs; i++) {
String fileName = TestDocument.getUrl(testDocuments[i]);
System.out.println("Doc " + i + ": " + fileName);
xTextDoc[i] = WriterTools.loadTextDoc(xMSF, fileName);
assertNotNull("Can't load document " + fileName, xTextDoc[i]);
}
}
/**
* Close the documents
*/
@After public void after() {
System.out.println("Close all documents.");
for (int i=0; i<countDocs; i++) {
xTextDoc[i].dispose();
}
}
/**
* Check the tdcp root.
*/
@Test public void checkTDOCRoot() {
try {
// create a content provider
Object o = xMSF.createInstance("com.sun.star.comp.ucb.TransientDocumentsContentProvider");
XContentProvider xContentProvider =
UnoRuntime.queryInterface(XContentProvider.class, o);
// create the ucb
XContentIdentifierFactory xContentIdentifierFactory =
UnoRuntime.queryInterface(XContentIdentifierFactory.class, xMSF.createInstance("com.sun.star.ucb.UniversalContentBroker"));
// create a content identifier from the ucb for tdoc
XContentIdentifier xContentIdentifier =
xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/");
// get content
xContent = xContentProvider.queryContent(xContentIdentifier);
String content = xContent.getContentType();
System.out.println("#### Content root: " + content);
// try to get some documents: should be "countDocs" at least.
XContentIdentifier[] xContentId = new XContentIdentifier[countDocs+5];
XContent[] xCont = new XContent[countDocs+5];
for (int i=0; i<countDocs+5; i++) {
xContentId[i] = xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/" + i);
// get content
xCont[i] = xContentProvider.queryContent(xContentId[i]);
int returnVal = xContentProvider.compareContentIds(xContentId[i], xContentIdentifier);
String cont = null;
if (xCont[i] != null)
{
cont = xCont[i].getContentType();
}
System.out.println("Document Content " + i + ": " + cont + " compare with root: " + returnVal);
xContentId[i] = xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/" + i + "/content.xml");
// get content
xCont[i] = xContentProvider.queryContent(xContentId[i]);
cont = null;
if (xCont[i] != null)
{
cont = xCont[i].getContentType();
}
System.out.println("\tContent.xml Content " + i + ": " + cont);
}
util.dbg.printInterfaces(xContent);
}
catch(Exception e) {
e.printStackTrace();
fail("Unexpected Exception: " + e.getMessage());
}
}
/**
* Check the interfaces of the root.
*/
@Test public void checkTDOCRootInterfaces() {
checkInterfaces(false);
}
/**
* Check the tdcp document: document 3 is used.
*/
@Test public void checkTDOCDocument() {
try {
xContent = null;
Object o = xMSF.createInstance("com.sun.star.comp.ucb.TransientDocumentsContentProvider");
XContentProvider xContentProvider =
UnoRuntime.queryInterface(XContentProvider.class, o);
// create the ucb
XContentIdentifierFactory xContentIdentifierFactory =
UnoRuntime.queryInterface(XContentIdentifierFactory.class, xMSF.createInstance("com.sun.star.ucb.UniversalContentBroker"));
// create a content identifier from the ucb for tdoc
XContentIdentifier xContentIdentifier =
xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/3");
// get content
xContent = xContentProvider.queryContent(xContentIdentifier);
// assertNotNull(xContent);
String content = xContent.getContentType();
System.out.println("#### Document root: " + content);
}
catch(Exception e) {
e.printStackTrace();
fail("Unexpected Exception: " + e.getMessage());
}
}
/**
* Check the interfaces on the document.
*/
@Test public void checkTDOCDocumentInterfaces() {
checkInterfaces(true);
}
/**
* Check a folder on document 2 (document 2 contains an embedded picture and
* therefore contans a subfolder "Pictures"
*/
@Test public void checkTDOCFolder() {
try {
xContent = null;
Object o = xMSF.createInstance("com.sun.star.comp.ucb.TransientDocumentsContentProvider");
XContentProvider xContentProvider =
UnoRuntime.queryInterface(XContentProvider.class, o);
// create the ucb
XContentIdentifierFactory xContentIdentifierFactory =
UnoRuntime.queryInterface(XContentIdentifierFactory.class, xMSF.createInstance("com.sun.star.ucb.UniversalContentBroker"));
// create a content identifier from the ucb for tdoc
XContentIdentifier xContentIdentifier =
xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/2/Pictures");
// get content
xContent = xContentProvider.queryContent(xContentIdentifier);
String content = xContent.getContentType();
System.out.println("#### Folder type: " + content);
}
catch(Exception e) {
e.printStackTrace();
fail("Unexpected Exception: " + e.getMessage());
}
}
/**
* Check the interfaces on the folder.
*/
@Test public void checkTDOCFolderInterfaces() {
checkInterfaces(true);
}
/**
* Open a stream to the embedded picture of document 1.
*/
@Test public void checkTDOCStream() {
try {
xContent = null;
Object o = xMSF.createInstance("com.sun.star.comp.ucb.TransientDocumentsContentProvider");
XContentProvider xContentProvider =
UnoRuntime.queryInterface(XContentProvider.class, o);
// create the ucb
XContentIdentifierFactory xContentIdentifierFactory =
UnoRuntime.queryInterface(XContentIdentifierFactory.class, xMSF.createInstance("com.sun.star.ucb.UniversalContentBroker"));
// create a content identifier from the ucb for tdoc
XContentIdentifier xContentIdentifier =
xContentIdentifierFactory.createContentIdentifier("vnd.sun.star.tdoc:/1/Pictures/10000000000000640000004B9C743800.gif");
// get content
xContent = xContentProvider.queryContent(xContentIdentifier);
String content = xContent.getContentType();
System.out.println("#### Folder type: " + content);
}
catch(Exception e) {
e.printStackTrace();
fail("Unexpected Exception: " + e.getMessage());
}
}
/**
* Check the interfaces on the stream.
*/
@Test public void checkTDOCStreamInterfaces() {
checkInterfaces(true);
}
/**
* Since all tdcp content types implement (nearly) the same interfaces, they
* are called here.
* Executed interface tests are (in this order):
* <ol>
* <li>XTypeProvider</li>
* <li>XServiceInfo</li>
* <li>XCommandProcessor</li>
* <li>XChild</li>
* <li>XPropertiesChangeNotifier</li>
* <li>XPropertySetInfoChangeNotifier</li>
* <li>XCommandInfoChangeNotifier</li>
* <li>XContent</li>
* <li>XPropertyContainer</li>
* <li>XComponent</li>
* </ol>
* @param hasParent True, if the tested content type does have a parent:
* only the root has not. Used in the XChild interface test.
*/
private void checkInterfaces(boolean hasParent) {
// check the XTypeProvider interface
_XTypeProvider xTypeProvider = new _XTypeProvider();
xTypeProvider.oObj = UnoRuntime.queryInterface(XTypeProvider.class, xContent);
// xTypeProvider.log = log;
assertNotNull("getImplementationId()", xTypeProvider._getImplementationId());
assertNotNull("getTypes()", xTypeProvider._getTypes());
// check the XSewrviceInfo interface
_XServiceInfo xServiceInfo = new _XServiceInfo();
xServiceInfo.oObj = UnoRuntime.queryInterface(XServiceInfo.class, xContent);
// xServiceInfo.log = log;
assertNotNull("getImplementationName()", xServiceInfo._getImplementationName());
assertNotNull("getSupportedServiceNames()", xServiceInfo._getSupportedServiceNames());
assertNotNull("supportsService()", xServiceInfo._supportsService());
// check the XCommandProcessor interface
_XCommandProcessor xCommandProcessor = new _XCommandProcessor();
xCommandProcessor.oObj = UnoRuntime.queryInterface(XCommandProcessor.class, xContent);
// xCommandProcessor.log = log;
xCommandProcessor.before(getMSF());
assertNotNull("createCommandIdentifier()", xCommandProcessor._createCommandIdentifier());
assertNotNull("execute()", xCommandProcessor._execute());
assertNotNull("abort()", xCommandProcessor._abort());
// check the XChild interface
_XChild xChild = new _XChild();
xChild.oObj = UnoRuntime.queryInterface(XChild.class, xContent);
// xChild.log = log;
// hasParent dermines, if this content has a parent
assertNotNull("getParent()", xChild._getParent(hasParent));
// parameter does dermine, if this funczion is supported: generally not supported with tdcp content
assertNotNull("setParent()", xChild._setParent(false));
// check the XPropertyChangeNotifier interface
_XPropertiesChangeNotifier xPropChange = new _XPropertiesChangeNotifier();
xPropChange.oObj = UnoRuntime.queryInterface(XPropertiesChangeNotifier.class, xContent);
// xPropChange.log = log;
assertNotNull("addPropertiesChangeListener()", xPropChange._addPropertiesChangeListener());
assertNotNull("removePropertiesChangeListener()", xPropChange._removePropertiesChangeListener());
// check the XPropertySetInfoChangeNotifier interface
_XPropertySetInfoChangeNotifier xPropSetInfo = new _XPropertySetInfoChangeNotifier();
xPropSetInfo.oObj = UnoRuntime.queryInterface(XPropertySetInfoChangeNotifier.class, xContent);
// xPropSetInfo.log = log;
assertNotNull("addPropertiesChangeListener()", xPropSetInfo._addPropertiesChangeListener());
assertNotNull("removePropertiesChangeListener()", xPropSetInfo._removePropertiesChangeListener());
// check the XCommandInfoChangeNotifier interface
_XCommandInfoChangeNotifier xCommandChange = new _XCommandInfoChangeNotifier();
xCommandChange.oObj = UnoRuntime.queryInterface(XCommandInfoChangeNotifier.class, xContent);
// xCommandChange.log = log;
assertNotNull("addCommandInfoChangeListener()", xCommandChange._addCommandInfoChangeListener());
assertNotNull("removeCommandInfoChangeListener()", xCommandChange._removeCommandInfoChangeListener());
// check the XContent interface
_XContent xCont = new _XContent();
xCont.oObj = UnoRuntime.queryInterface(XContent.class, xContent);
// xCont.log = log;
assertNotNull("addContentEventListener()", xCont._addContentEventListener());
assertNotNull("getContentType()", xCont._getContentType());
assertNotNull("getIdentifier()", xCont._getIdentifier());
assertNotNull("removeContentEventListener()", xCont._removeContentEventListener());
// check the XPropertyContainer interface
_XPropertyContainer xPropCont = new _XPropertyContainer();
xPropCont.oObj = UnoRuntime.queryInterface(XPropertyContainer.class, xContent);
// xPropCont.log = log;
assertNotNull("addProperty()", xPropCont._addProperty());
assertNotNull("removeProperty()", xPropCont._removeProperty());
// check the XComponent interface
_XComponent xComponent = new _XComponent();
xComponent.oObj = UnoRuntime.queryInterface(XComponent.class, xContent);
// xComponent.log = log;
assertNotNull("addEventListener()", xComponent._addEventListener());
assertNotNull("removeEventListener()", xComponent._removeEventListener());
// assure("dispose()", xComponent._dispose());
}
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("setUpConnection()");
connection.setUp();
}
@AfterClass public static void tearDownConnection()
throws InterruptedException, com.sun.star.uno.Exception
{
System.out.println("tearDownConnection()");
connection.tearDown();
}
private static final OfficeConnection connection = new OfficeConnection();
}