diff options
Diffstat (limited to 'qadevOOo/tests/java/ifc/bridge')
| -rw-r--r-- | qadevOOo/tests/java/ifc/bridge/_XBridge.java | 141 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/bridge/_XBridgeFactory.java | 222 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/bridge/_XUnoUrlResolver.java | 193 |
3 files changed, 556 insertions, 0 deletions
diff --git a/qadevOOo/tests/java/ifc/bridge/_XBridge.java b/qadevOOo/tests/java/ifc/bridge/_XBridge.java new file mode 100644 index 000000000..4e1833284 --- /dev/null +++ b/qadevOOo/tests/java/ifc/bridge/_XBridge.java @@ -0,0 +1,141 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +package ifc.bridge; + +import lib.MultiMethodTest; +import lib.Status; +import lib.StatusException; + +import com.sun.star.bridge.XBridge; +import com.sun.star.connection.XConnection; +import com.sun.star.lang.XInitialization; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + + +/** +* Testing <code>com.sun.star.bridge.XBridge</code> +* interface methods : +* <ul> +* <li><code> getInstance()</code></li> +* <li><code> getName()</code></li> +* <li><code> getDescription()</code></li> +* </ul> <p> +* This test needs the following object relations : +* <ul> +* <li> <code>'XInitialization.args'</code> (of type <code>Object[]</code>): +* relation which contains arguments for Bridge initialization. +* It used here to check description of the bridge. This array +* must contain : [0] - the name of the bridge, [1] - the name of +* protocol, [2] - <code>XConnection</code> reference to bridge +* connection. </li> +* <ul> <p> +* Test is <b> NOT </b> multithread compliant. <p> +* After test completion object environment has to be recreated. +* @see com.sun.star.bridge.XBridge +*/ +public class _XBridge extends MultiMethodTest { + + public XBridge oObj; + + protected Object[] args;//for object relation 'XInitialization.args' + + /** + * Retrieves object relations. + * @throws StatusException If one of relations not found. + */ + @Override + public void before() { + args = (Object[])tEnv.getObjRelation("XInitialization.args"); + + if (args == null) throw new StatusException(Status.failed + ("Relation 'XInitialization.args' not found")) ; + XInitialization xInit = UnoRuntime.queryInterface( + XInitialization.class, oObj); + try { + xInit.initialize(args); + } + catch (com.sun.star.uno.Exception e) { + e.printStackTrace(log); + throw new StatusException("Can't initialize the bridge", e); + } + } + + /** + * Tries to retrieve <code>ServiceManager</code> service + * using the bridge. <p> + * Has <b>OK</b> status if non null object returned. + */ + public void _getInstance() { + XInterface xInt = (XInterface)oObj.getInstance( + "com.sun.star.lang.ServiceManager"); + + tRes.tested("getInstance()", xInt != null); + } + + /** + * Retrieves the name of the bridge from relation and compares + * it to name returned by the method. <p> + * Has <b>OK</b> status if names are equal. + */ + public void _getName() { + String expectedName = (String)args[0]; // args[0] - bridge name + + String name = oObj.getName(); + + if (!tRes.tested("getName()", name.equals(expectedName))) { + log.println("getName() returns wrong result : \"" + name + "\""); + log.println("expected = \"" + expectedName + "\""); + } + } + + /** + * Retrieves the description of the bridge and compares it with + * expected description composed using relation + * <code> ([protocol] + ":" + [connection description]) </code>. <p> + * Has <b>OK</b> status if description returned by the method + * is equal to expected one. + */ + public void _getDescription() { + String protocol = (String)args[1]; // args[1] - protocol + XConnection xConnection = (XConnection)args[2]; // args[2] - connection + // expected description is protocol + ":" + xConnection.getDescription() + String expectedDescription = + protocol + ":" + xConnection.getDescription(); + + String description = oObj.getDescription(); + + if (!tRes.tested("getDescription()", + description.equals(expectedDescription))) { + log.println("getDescription() returns wrong result : \"" + + description + "\""); + log.println("expected = \"" + expectedDescription + "\""); + } + } + + /** + * Disposes object environment. + */ + @Override + public void after() { + disposeEnvironment() ; + } + +} + diff --git a/qadevOOo/tests/java/ifc/bridge/_XBridgeFactory.java b/qadevOOo/tests/java/ifc/bridge/_XBridgeFactory.java new file mode 100644 index 000000000..fe0f28d69 --- /dev/null +++ b/qadevOOo/tests/java/ifc/bridge/_XBridgeFactory.java @@ -0,0 +1,222 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +package ifc.bridge; + +import lib.MultiMethodTest; +import lib.StatusException; + +import com.sun.star.bridge.XBridge; +import com.sun.star.bridge.XBridgeFactory; +import com.sun.star.connection.XAcceptor; +import com.sun.star.connection.XConnection; +import com.sun.star.connection.XConnector; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; + +/** +* Tests <code>com.sun.star.bridge.XBridgeFactory</code> +* interface methods : +* <ul> +* <li><code> createBridge()</code></li> +* <li><code> getBridge()</code></li> +* <li><code> getExistingBridges()</code></li> +* </ul> <p> +* @see com.sun.star.bridge.XBridgeFactory +*/ +public class _XBridgeFactory extends MultiMethodTest { + + public XBridgeFactory oObj = null; + + private String bridgeName = null ; + + AcceptorThread acceptorThread = null; + + /** + * Interrupts the acceptor after test is finished + */ + @Override + protected void after() { + acceptorThread.acc.stopAccepting(); + if (acceptorThread.isAlive()) { + acceptorThread.interrupt(); + } + } + /** + * Calls <code>accept()</code> method in a separate thread. + * Then stores exception thrown by call if it occurred, or + * return value. + */ + protected class AcceptorThread extends Thread { + /** + * the acceptor + */ + private final XAcceptor acc; + /** + * If exception occurred during method call it is + * stored in this field. + */ + public Exception ex = null ; + /** + * If method call returns some value it stores in this field. + */ + public XConnection acceptedCall = null ; + + /** + * Gets an object which can call <code>accept</code> method. + */ + public AcceptorThread(XAcceptor acc) { + this.acc = acc ; + } + + /** + * Call <code>accept()</code> method. + */ + @Override + public void run() { + try { + acceptedCall = acc.accept(connectString); + } catch (com.sun.star.lang.IllegalArgumentException e) { + ex = e ; + } catch (com.sun.star.connection.ConnectionSetupException e) { + ex = e ; + } catch (com.sun.star.connection.AlreadyAcceptingException e) { + ex = e ; + } + } + } + + /** + * Variable to make bridge names unique in different threads. + */ + public static int uniqueSuffix = 0 ; + /** + * Object for synchronizing <code>uniqueSuffix</code> increment. + */ + public static Object synchFlag = new Object() ; + /** + * Connection string + */ + public String connectString; + + /** + * Gets array of existing bridges. <p> + * Has <b>OK</b> status if method returns not null. + */ + public void _getExistingBridges() { + + XBridge[] bridges = oObj.getExistingBridges() ; + + log.println("Existing bridges :") ; + for (int i = 0; i < bridges.length; i++) + log.println(" " + bridges[i].getDescription()) ; + + if (bridges.length > 0) bridgeName = bridges[0].getName() ; + + tRes.tested("getExistingBridges()", true) ; + } + + /** + * First creates connection with StarOffice process, using environment + * property <code>'CONNECTION_STRING'</code>. Then create bridge with unique name + * using protocol specified in environment as <code>'PROTOCOL'</code> + * property. After that bridge is disposed. <p> + * Has <b>OK</b> status if value returned is not null + * and no exceptions were thrown.<p> + */ + public void _createBridge() { + XBridge bridge = null; + XConnection conn = null ; + boolean result = false ; + + // first creating a connection + try { + XInterface x = (XInterface) + tParam.getMSF().createInstance + ("com.sun.star.connection.Connector") ; + + XConnector xCntr = UnoRuntime.queryInterface + (XConnector.class, x) ; + + x = (XInterface) tParam.getMSF().createInstance + ("com.sun.star.connection.Acceptor") ; + + XAcceptor xAccptr = UnoRuntime.queryInterface( + XAcceptor.class, x); + connectString = (String)tEnv.getObjRelation("CNNCTSTR"); + acceptorThread = new AcceptorThread(xAccptr) ; + acceptorThread.start(); + + util.utils.shortWait(); + conn = xCntr.connect(connectString) ; + + } catch (com.sun.star.uno.Exception e) { + e.printStackTrace(log) ; + throw new StatusException("Can't create connection", e); + } + + try { + String protocol = (String) tParam.get("PROTOCOL") ; + if (protocol == null) protocol = "urp" ; + + String brName ; + synchronized (synchFlag) { + brName = "MyBridge" + (uniqueSuffix++) ; + } + + log.println("Creating bridge with name " + brName) ; + + bridge = oObj.createBridge(brName, + protocol, conn, null) ; + + + result = bridge != null ; + } catch (com.sun.star.bridge.BridgeExistsException e) { + log.println("Exception while bridge creating :" + e) ; + } catch (com.sun.star.lang.IllegalArgumentException e) { + log.println("Exception while bridge creating :" + e) ; + } + + tRes.tested("createBridge()", result) ; + } + + /** + * Gets bridge by name and checks the bridge name returned. <p> + * The following method tests are to be executed before : + * <ul> + * <li> <code>getExestingBridges</code> : to have some bridge name + * to retrieve </li> + * </ul> <p> + * Has <b>OK</b> status if bridge successfully returned and its name + * equals to name passed as parameter. + */ + public void _getBridge() { + executeMethod("getExistingBridges()") ; + + if (bridgeName == null) { + log.println("No name for getting the bridge") ; + return ; + } + + XBridge br = oObj.getBridge(bridgeName) ; + + tRes.tested("getBridge()", br != null && + bridgeName.equals(br.getName())) ; + } +} + diff --git a/qadevOOo/tests/java/ifc/bridge/_XUnoUrlResolver.java b/qadevOOo/tests/java/ifc/bridge/_XUnoUrlResolver.java new file mode 100644 index 000000000..16bbceb45 --- /dev/null +++ b/qadevOOo/tests/java/ifc/bridge/_XUnoUrlResolver.java @@ -0,0 +1,193 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +package ifc.bridge; + +import lib.MultiMethodTest; +import lib.StatusException; +import util.utils; + +import com.sun.star.bridge.XBridge; +import com.sun.star.bridge.XBridgeFactory; +import com.sun.star.bridge.XInstanceProvider; +import com.sun.star.bridge.XUnoUrlResolver; +import com.sun.star.connection.ConnectionSetupException; +import com.sun.star.connection.NoConnectException; +import com.sun.star.connection.XAcceptor; +import com.sun.star.connection.XConnection; +import com.sun.star.lang.IllegalArgumentException; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.uno.UnoRuntime; + +/** +* Testing <code>com.sun.star.bridge.XUnoUrlResolver</code> +* interface methods : +* <ul> +* <li><code> resolve()</code></li> +* </ul> <p> +* @see com.sun.star.bridge.XUnoUrlResolver +*/ +public class _XUnoUrlResolver extends MultiMethodTest { + + // starting port and current port to choose + static int basePort = 0; + int curPort = 0; + + public XUnoUrlResolver oObj; + + /** + * Implementation for providing an instance + * + * @see com.sun.star.bridge.XInstanceProvider + */ + static class MyInstanceProvider implements XInstanceProvider { + /** + * a MultiServiceFactory for creating instances + * + * @see com.sun.star.lang.MultiServiceFactory + */ + private final XMultiServiceFactory xMSF; + + /** + * Construct object with a MultiServiceFactory + * + * @see com.sun.star.lang.MultiServiceFactory + */ + public MyInstanceProvider(XMultiServiceFactory xMSF) { + this.xMSF = xMSF; + } + + /** + * get an instance by name + */ + public Object getInstance(String aInstanceName) + throws com.sun.star.container.NoSuchElementException + { + try { + return xMSF.createInstance(aInstanceName); + } + catch(com.sun.star.uno.Exception e) { + throw new StatusException("Unexpected exception", e); + } + } + } + + /** + * Thread for creating a bridge so the resolver can access it + */ + class BridgeThread extends Thread { + private final XBridgeFactory xBrdgFctr; + private final XInstanceProvider xInstProv; + private final XAcceptor xAcc; + private final String connectString; + + public XBridge xBridge = null; + + public BridgeThread(XAcceptor xAcc, XBridgeFactory xBrdgFctr, + XInstanceProvider xInstProv, String connectString) { + this.xInstProv = xInstProv; + this.xBrdgFctr = xBrdgFctr; + this.xAcc = xAcc; + this.connectString = connectString; + } + + @Override + public void run() { + try { + // create a connection + XConnection xCon = xAcc.accept(connectString); + // create a bridge over that connection + xBridge = xBrdgFctr.createBridge( + "MyBridge", "urp", xCon, xInstProv); + } catch (com.sun.star.lang.IllegalArgumentException e) { + e.printStackTrace(log); + } catch (com.sun.star.connection.ConnectionSetupException e) { + e.printStackTrace(log); + } catch (com.sun.star.connection.AlreadyAcceptingException e) { + e.printStackTrace(log); + } catch (com.sun.star.bridge.BridgeExistsException e) { + e.printStackTrace(log); + } + } + + } + /** + * Test calls the method using environment property + * <code>'CONNECTION_STRING'</code>. <p> + * Has <b> OK </b> status if the method successfully returns + * object that support interface <code>XMultiServiceFactory</code> and + * no exceptions were thrown. <p> + * @see com.sun.star.lang.XMultiServiceFactory + */ + public void _resolve() { + String connectStr = (String)tParam.get("CONNECTION_STRING"); + int pIndex = connectStr.indexOf("port=") + 5; + connectStr = connectStr.substring(0, pIndex); + System.out.println("ConnectString: " + connectStr); + + // select the port + basePort = ((Integer)tEnv.getObjRelation("PORT")).intValue(); + curPort = utils.getNextFreePort(basePort); + log.println("Choose Port nr: " + curPort); + + connectStr += curPort; + + try { + XMultiServiceFactory xMSF = tParam.getMSF(); + + // get the bridge factory + XBridgeFactory xBrdgFctr = UnoRuntime.queryInterface(XBridgeFactory.class, + tEnv.getObjRelation("BRIDGEFACTORY")); + + // get the acceptor + XAcceptor xAcc = UnoRuntime.queryInterface( + XAcceptor.class, tEnv.getObjRelation("ACCEPTOR")); + + // instance provider + XInstanceProvider xInstProv = new MyInstanceProvider(xMSF); + // thread for providing a bridge + BridgeThread brThread = new BridgeThread(xAcc, xBrdgFctr, + xInstProv, connectStr); + brThread.start(); + + util.utils.shortWait(); + // get an instance from the remote + Object obj = oObj.resolve( + "uno:" + connectStr + ";urp;com.sun.star.lang.ServiceManager"); + // got the instance? + XMultiServiceFactory oMSF = UnoRuntime.queryInterface(XMultiServiceFactory.class, obj); + + if (brThread.isAlive()) + brThread.interrupt(); + + tRes.tested("resolve()", oMSF != null); + } catch (NoConnectException e) { + log.println("Unexpected exception thrown " + e.getMessage()); + e.printStackTrace(log); + throw new StatusException("Unexpected exception", e); + } catch (ConnectionSetupException e) { + log.println("Unexpected exception thrown " + e.getMessage()); + e.printStackTrace(log); + throw new StatusException("Unexpected exception", e); + } catch (IllegalArgumentException e) { + log.println("Unexpected exception thrown " + e.getMessage()); + e.printStackTrace(log); + throw new StatusException("Unexpected exception", e); + } + } +} |