INTEGRATION: CWS sb7 (1.2.2); FILE MERGED

2003/08/07 12:46:20 sb 1.2.2.3: #i16264# Correctly implement URP spec of not acquiring (oid,t) upon mapping out if (oid,t') with t' subtype of t was mapped in.
2003/07/23 11:40:48 sb 1.2.2.2: #i16264# Improved tests, with both clients and servers in both Java and C++.
2003/07/18 07:38:40 sb 1.2.2.1: #110892# Improved test case output.

1 files changed, 269 insertions, 154 deletions

diff --git a/bridges/test/java_uno/acquire/TestAcquire.java b/bridges/test/java_uno/acquire/TestAcquire.java
index f0edf8ef6..78e8d3fe4 100644
--- a/bridges/test/java_uno/acquire/TestAcquire.java
+++ b/bridges/test/java_uno/acquire/TestAcquire.java
@@ -2,9 +2,9 @@
  *
  *  $RCSfile: TestAcquire.java,v $
  *
- *  $Revision: 1.2 $
+ *  $Revision: 1.3 $
  *
- *  last change: $Author: vg $ $Date: 2003-07-09 09:20:40 $
+ *  last change: $Author: hr $ $Date: 2003-08-13 17:21:16 $
  *
  *  The Contents of this file are made available subject to the terms of
  *  either of the following licenses
@@ -59,172 +59,287 @@
  *
  ************************************************************************/
 
-package test.java_uno.acquire;
+package test.javauno.acquire;
 
+import com.sun.star.bridge.XBridgeFactory;
+import com.sun.star.bridge.XInstanceProvider;
 import com.sun.star.bridge.XUnoUrlResolver;
 import com.sun.star.comp.helper.Bootstrap;
-import com.sun.star.uno.Any;
+import com.sun.star.connection.XAcceptor;
+import com.sun.star.connection.XConnection;
+import com.sun.star.lib.uno.helper.UnoUrl;
 import com.sun.star.uno.UnoRuntime;
 import com.sun.star.uno.XComponentContext;
 import com.sun.star.uno.XInterface;
+import util.WaitUnreachable;
 
 public final class TestAcquire {
-    // args[0] must be the UNO URL to connect to
-    public static void main(String[] args) throws Exception {
+    public static void main(String[] arguments) throws Exception {
+        // - arguments[0] must be "client" or "server"
+        // - arguments[1] must be the UNO URL to connect to (client) or accept
+        //   on (server)
         XComponentContext context
             = Bootstrap.createInitialComponentContext(null);
+        if (arguments[0].equals("client")) {
+            execClient(context, arguments[1]);
+        } else {
+            execServer(context, arguments[1]);
+        }
+    }
+
+    private static void assertNotNull(Object obj) {
+        if (obj == null) {
+            throw new RuntimeException("assertNotNull failed");
+        }
+    }
+
+    private static void receive(Object obj) {
+        assertNotNull(obj);
+        WaitUnreachable.ensureFinalization(obj);
+    }
+
+    private static void execClient(XComponentContext context, String url)
+        throws Exception
+    {
         XUnoUrlResolver resolver = (XUnoUrlResolver) UnoRuntime.queryInterface(
             XUnoUrlResolver.class,
             context.getServiceManager().createInstanceWithContext(
                 "com.sun.star.bridge.UnoUrlResolver", context));
         XTest test = (XTest) UnoRuntime.queryInterface(
-            XTest.class, resolver.resolve(args[0]));
-
-        // A minimal test for #110444#:
-        test.setDerivedToDerived(new XDerived() {});
-        test.getDerivedFromDerived();
-
-/*
-        // A test that crashes the server, because roundTripDerivedToInterface
-        // sends back a "release" for the tuple (someDerived,XInterface) from
-        // the client to the server, altough the server did not acquire this
-        // tuple when sending it, since earlier the server received the tuple
-        // (someDerived,XDerived) from the client (and XDerived is a subtype of
-        // XInterface):
-        XBase someBase = new XBase() {};
-        XDerived someDerived = new XDerived() {};
-        test.setAnyToBase(new Any(XBase.class, someBase));
-        test.setAnyToBase(new Any(XBase.class, someDerived));
-        test.getInterfaceFromBase();
-        test.roundTripDerivedToInterface(someDerived);
-*/
-
-/*
-        // The complete test suite:
-
-        test.setInterfaceToInterface(new XInterface() {});
-        test.getInterfaceFromInterface();
-        test.setInterfaceToInterface(new XBase() {});
-        test.getInterfaceFromInterface();
-        test.setInterfaceToInterface(new XDerived() {});
-        test.getInterfaceFromInterface();
-
-        test.setBaseToInterface(new XBase() {});
-        test.getInterfaceFromInterface();
-        test.setBaseToInterface(new XDerived() {});
-        test.getInterfaceFromInterface();
-
-        test.setDerivedToInterface(new XDerived() {});
-        test.getInterfaceFromInterface();
-
-        test.setAnyToInterface(new XInterface() {});
-        test.getInterfaceFromInterface();
-        test.setAnyToInterface(new XBase() {});
-        test.getInterfaceFromInterface();
-        test.setAnyToInterface(new XDerived() {});
-        test.getInterfaceFromInterface();
-        test.setAnyToInterface(new Any(XBase.class, new XBase() {}));
-        test.getInterfaceFromInterface();
-        test.setAnyToInterface(new Any(XBase.class, new XDerived() {}));
-        test.getInterfaceFromInterface();
-        test.setAnyToInterface(new Any(XDerived.class, new XDerived() {}));
-        test.getInterfaceFromInterface();
-
-        test.setBaseToBase(new XBase() {});
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-        test.setBaseToBase(new XDerived() {});
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-
-        test.setDerivedToBase(new XDerived() {});
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-
-        test.setAnyToBase(new XBase() {});
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-        test.setAnyToBase(new XDerived() {});
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-        test.setAnyToBase(new Any(XBase.class, new XBase() {}));
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-        test.setAnyToBase(new Any(XBase.class, new XDerived() {}));
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-        test.setAnyToBase(new Any(XBase.class, new XDerived() {}));
-        test.getInterfaceFromBase();
-        test.getBaseFromBase();
-
-        test.setDerivedToDerived(new XDerived() {});
-        test.getInterfaceFromDerived();
-        test.getBaseFromDerived();
-        test.getDerivedFromDerived();
-
-        test.setAnyToDerived(new XDerived() {});
-        test.getInterfaceFromDerived();
-        test.getBaseFromDerived();
-        test.getDerivedFromDerived();
-        test.setAnyToDerived(new Any(XDerived.class, new XDerived() {}));
-        test.getInterfaceFromDerived();
-        test.getBaseFromDerived();
-        test.getDerivedFromDerived();
-
-        test.setAnyToAny(new XInterface() {});
-        test.getAnyFromAny();
-        test.setAnyToAny(new XBase() {});
-        test.getAnyFromAny();
-        test.setAnyToAny(new XDerived() {});
-        test.getAnyFromAny();
-        test.setAnyToAny(new Any(XBase.class, new XBase() {}));
-        test.getAnyFromAny();
-        test.setAnyToAny(new Any(XBase.class, new XDerived() {}));
-        test.getAnyFromAny();
-        test.setAnyToAny(new Any(XDerived.class, new XDerived() {}));
-        test.getAnyFromAny();
-
-        test.roundTripInterfaceToInterface(new XInterface() {});
-        test.roundTripInterfaceToInterface(new XBase() {});
-        test.roundTripInterfaceToInterface(new XDerived() {});
-
-        test.roundTripBaseToInterface(new XBase() {});
-        test.roundTripBaseToInterface(new XDerived() {});
-
-        test.roundTripDerivedToInterface(new XDerived() {});
-
-        test.roundTripAnyToInterface(new XInterface() {});
-        test.roundTripAnyToInterface(new XBase() {});
-        test.roundTripAnyToInterface(new XDerived() {});
-        test.roundTripAnyToInterface(new Any(XBase.class, new XBase() {}));
-        test.roundTripAnyToInterface(new Any(XBase.class, new XDerived() {}));
-        test.roundTripAnyToInterface(new Any(XDerived.class,
-                                             new XDerived() {}));
-
-        test.roundTripBaseToBase(new XBase() {});
-        test.roundTripBaseToBase(new XDerived() {});
-
-        test.roundTripDerivedToBase(new XDerived() {});
-
-        test.roundTripAnyToBase(new XBase() {});
-        test.roundTripAnyToBase(new XDerived() {});
-        test.roundTripAnyToBase(new Any(XBase.class, new XBase() {}));
-        test.roundTripAnyToBase(new Any(XBase.class, new XDerived() {}));
-        test.roundTripAnyToBase(new Any(XDerived.class, new XDerived() {}));
-
-        test.roundTripDerivedToDerived(new XDerived() {});
-
-        test.roundTripAnyToDerived(new XDerived() {});
-        test.roundTripAnyToDerived(new Any(XDerived.class, new XDerived() {}));
-
-        test.roundTripAnyToAny(new XInterface() {});
-        test.roundTripAnyToAny(new XBase() {});
-        test.roundTripAnyToAny(new XDerived() {});
-        test.roundTripAnyToAny(new Any(XBase.class, new XBase() {}));
-        test.roundTripAnyToAny(new Any(XBase.class, new XDerived() {}));
-        test.roundTripAnyToAny(new Any(XDerived.class, new XDerived() {}));
-*/
-
-        System.exit(0);
+            XTest.class, resolver.resolve(url));
+
+        WaitUnreachable u;
+
+        u = new WaitUnreachable(new XInterface() {});
+        test.setInterfaceToInterface((XInterface) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XBase() {});
+        test.setInterfaceToInterface((XBase) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        test.setInterfaceToInterface((XDerived) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XBase() {});
+        test.setBaseToInterface((XBase) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        test.setBaseToInterface((XDerived) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        test.setDerivedToInterface((XDerived) u.get());
+        receive(test.getInterfaceFromInterface());
+        test.clearInterface();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XBase() {});
+        test.setBaseToBase((XBase) u.get());
+        receive(test.getInterfaceFromBase());
+        receive(test.getBaseFromBase());
+        test.clearBase();
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        test.setBaseToBase((XDerived) u.get());
+        receive(test.getInterfaceFromBase());
+        receive(test.getBaseFromBase());
+        test.clearBase();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        test.setDerivedToBase((XDerived) u.get());
+        receive(test.getInterfaceFromBase());
+        receive(test.getBaseFromBase());
+        test.clearBase();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        test.setDerivedToDerived((XDerived) u.get());
+        receive(test.getInterfaceFromDerived());
+        receive(test.getBaseFromDerived());
+        receive(test.getDerivedFromDerived());
+        test.clearDerived();
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XInterface() {});
+        receive(test.roundTripInterfaceToInterface((XInterface) u.get()));
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XBase() {});
+        receive(test.roundTripInterfaceToInterface((XBase) u.get()));
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripInterfaceToInterface((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XBase() {});
+        receive(test.roundTripBaseToInterface((XBase) u.get()));
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripBaseToInterface((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripDerivedToInterface((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XBase() {});
+        receive(test.roundTripBaseToBase((XBase) u.get()));
+        u.waitUnreachable();
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripBaseToBase((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripDerivedToBase((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(new XDerived() {});
+        receive(test.roundTripDerivedToDerived((XDerived) u.get()));
+        u.waitUnreachable();
+
+        u = new WaitUnreachable(test);
+        test = null;
+        u.waitUnreachable();
+        System.out.println(
+            "Client and server both cleanly terminate now: Success");
+    }
+
+    private static void execServer(XComponentContext context, String url)
+        throws Exception
+    {
+        XBridgeFactory bridgeFactory
+            = (XBridgeFactory) UnoRuntime.queryInterface(
+                XBridgeFactory.class,
+                context.getServiceManager().createInstanceWithContext(
+                    "com.sun.star.bridge.BridgeFactory", context));
+        XAcceptor acceptor = (XAcceptor) UnoRuntime.queryInterface(
+            XAcceptor.class,
+            context.getServiceManager().createInstanceWithContext(
+                "com.sun.star.connection.Acceptor", context));
+        UnoUrl unoUrl = UnoUrl.parseUnoUrl(url);
+        System.out.println("Server: Accepting...");
+        XConnection connection = acceptor.accept(
+            unoUrl.getConnectionAndParametersAsString());
+        System.out.println("Server: ...connected...");
+        bridgeFactory.createBridge(
+            "", unoUrl.getProtocolAndParametersAsString(), connection,
+            new Provider());
+        System.out.println("Server: ...bridged.");
+    }
+
+    private static final class Provider implements XInstanceProvider {
+        public Object getInstance(String instanceName) {
+            return new XTest() {
+                    public void setInterfaceToInterface(Object obj) {
+                        iface = obj;
+                    }
+
+                    public void setBaseToInterface(XBase obj) {
+                        iface = obj;
+                    }
+
+                    public void setDerivedToInterface(XDerived obj) {
+                        iface = obj;
+                    }
+
+                    public Object getInterfaceFromInterface() {
+                        return iface;
+                    }
+
+                    public void clearInterface() {
+                        WaitUnreachable u = new WaitUnreachable(iface);
+                        iface = null;
+                        u.waitUnreachable();
+                    }
+
+                    public void setBaseToBase(XBase obj) {
+                        base = obj;
+                    }
+
+                    public void setDerivedToBase(XDerived obj) {
+                        base = obj;
+                    }
+
+                    public Object getInterfaceFromBase() {
+                        return base;
+                    }
+
+                    public XBase getBaseFromBase() {
+                        return base;
+                    }
+
+                    public void clearBase() {
+                        WaitUnreachable u = new WaitUnreachable(base);
+                        base = null;
+                        u.waitUnreachable();
+                    }
+
+                    public void setDerivedToDerived(XDerived obj) {
+                        derived = obj;
+                    }
+
+                    public Object getInterfaceFromDerived() {
+                        return derived;
+                    }
+
+                    public XBase getBaseFromDerived() {
+                        return derived;
+                    }
+
+                    public XDerived getDerivedFromDerived() {
+                        return derived;
+                    }
+
+                    public void clearDerived() {
+                        WaitUnreachable u = new WaitUnreachable(derived);
+                        derived = null;
+                        u.waitUnreachable();
+                    }
+
+                    public Object roundTripInterfaceToInterface(Object obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    public Object roundTripBaseToInterface(XBase obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    public Object roundTripDerivedToInterface(XDerived obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    public XBase roundTripBaseToBase(XBase obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    public XBase roundTripDerivedToBase(XDerived obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    public XDerived roundTripDerivedToDerived(XDerived obj) {
+                        WaitUnreachable.ensureFinalization(obj);
+                        return obj;
+                    }
+
+                    private Object iface;
+                    private XBase base;
+                    private XDerived derived;
+                };
+        }
     }
 }