Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

28 files changed, 4601 insertions, 0 deletions

diff --git a/ridljar/test/com/sun/star/comp/bridgefactory/BridgeFactory_Test.java b/ridljar/test/com/sun/star/comp/bridgefactory/BridgeFactory_Test.java
new file mode 100644
index 000000000..965653bf7
--- /dev/null
+++ b/ridljar/test/com/sun/star/comp/bridgefactory/BridgeFactory_Test.java
@@ -0,0 +1,92 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.comp.bridgefactory;
+
+import com.sun.star.bridge.BridgeExistsException;
+import com.sun.star.bridge.XBridge;
+import com.sun.star.comp.connections.PipedConnection;
+import com.sun.star.lang.XComponent;
+import com.sun.star.uno.UnoRuntime;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class BridgeFactory_Test {
+    @Test public void test() throws Exception {
+        PipedConnection rightSide = new PipedConnection(new Object[0]);
+        PipedConnection leftSide = new PipedConnection(new Object[]{rightSide});
+
+        BridgeFactory bridgeFactory = new BridgeFactory(); // create the needed bridgeFactory
+
+        // create a bridge
+        XBridge xBridge = bridgeFactory.createBridge("testbridge", "urp", leftSide, null);
+
+        // test that we get the same bridge
+        assertTrue(
+            UnoRuntime.areSame(
+                xBridge, bridgeFactory.getBridge("testbridge")));
+
+        // test that we can not create another bridge with same name
+        try {
+            bridgeFactory.createBridge("testbridge", "urp", leftSide, null);
+
+            fail();
+        }
+        catch(BridgeExistsException bridgeExistsException) {
+        }
+
+
+        // test getExistingBridges
+        XBridge xBridges[] = bridgeFactory.getExistingBridges();
+        assertTrue(UnoRuntime.areSame(xBridge, xBridges[0]));
+
+        // dispose the bridge
+        XComponent xComponent = UnoRuntime.queryInterface(XComponent.class, xBridge);
+        xComponent.dispose();
+
+
+        // test that the bridge has been removed
+        assertTrue(bridgeFactory.getBridge("testbridge") == null);
+
+
+
+        rightSide = new PipedConnection(new Object[0]);
+        leftSide = new PipedConnection(new Object[]{rightSide});
+
+
+        // test that we really get a new bridge
+        XBridge xBridge_new = bridgeFactory.createBridge("testbridge", "urp", leftSide, null);
+        assertFalse(UnoRuntime.areSame(xBridge, xBridge_new));
+
+        for(int i = 0; i <10000; ++ i) {
+            Object x[] = new Object[100];
+        }
+
+        // test getExistingBridges
+        xBridges = bridgeFactory.getExistingBridges();
+        assertEquals(1, xBridges.length);
+        assertTrue(UnoRuntime.areSame(xBridge_new, xBridges[0]));
+
+        // dispose the new bridge
+        XComponent xComponent_new = UnoRuntime.queryInterface(XComponent.class, xBridge_new);
+        xComponent_new.dispose();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/comp/connections/PipedConnection_Test.java b/ridljar/test/com/sun/star/comp/connections/PipedConnection_Test.java
new file mode 100644
index 000000000..6cfef789d
--- /dev/null
+++ b/ridljar/test/com/sun/star/comp/connections/PipedConnection_Test.java
@@ -0,0 +1,104 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.comp.connections;
+
+import com.sun.star.io.IOException;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class PipedConnection_Test {
+    private static final int ROUNDS = 2000;
+
+    @Test public void test() throws Exception {
+        PipedConnection rightSide = new PipedConnection(new Object[0]);
+        PipedConnection leftSide = new PipedConnection(new Object[]{rightSide});
+
+        Reader reader = new Reader(rightSide);
+        Writer writer = new Writer(leftSide);
+
+        reader.start();
+        writer.start();
+
+        writer.join();
+        reader.join();
+
+        assertTrue(writer._state);
+        assertTrue(reader._state);
+        assertEquals(ROUNDS, reader._rounds);
+    }
+
+    private static class Reader extends Thread {
+        PipedConnection _pipedConnection;
+        boolean _state = false;
+        int _rounds = 0;
+
+        Reader(PipedConnection pipedConnection) {
+            _pipedConnection = pipedConnection;
+        }
+
+        @Override
+        public void run() {
+            try {
+                for (byte v = 0;; v++) {
+                    byte[][] b = new byte[1][];
+                    int n = _pipedConnection.read(b, 1);
+                    if (n == 0) {
+                        break;
+                    }
+                    assertEquals(1, n);
+                    assertEquals(1, b[0].length);
+                    assertEquals(v, b[0][0]);
+                    ++_rounds;
+                }
+                _pipedConnection.close();
+                _state = true;
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    private static class Writer extends Thread {
+        PipedConnection _pipedConnection;
+        boolean _state = false;
+
+        Writer(PipedConnection pipedConnection) {
+            _pipedConnection = pipedConnection;
+        }
+
+        @Override
+        public void run() {
+            try {
+                byte v = 0;
+                for (int i = 0; i != ROUNDS; ++i) {
+                    byte[] b = new byte[] { v++ };
+                    _pipedConnection.write(b);
+                    _pipedConnection.flush();
+                }
+                _pipedConnection.close();
+                _state = true;
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/BridgedObject_Test.java b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/BridgedObject_Test.java
new file mode 100644
index 000000000..e7dc9c0e1
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/BridgedObject_Test.java
@@ -0,0 +1,64 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.bridges.java_remote;
+
+import com.sun.star.bridge.XBridge;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.XInterface;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class BridgedObject_Test {
+    @Test public void test() {
+        RequestHandler handler = new RequestHandler() {
+                public Object sendRequest(
+                    String oid, Type type, String operation, Object[] args)
+                {
+                    return null;
+                }
+            };
+        XBridge bridge1 = new TestBridge();
+        ProxyFactory factory1 = new ProxyFactory(handler, bridge1);
+        XBridge bridge2 = new TestBridge();
+        ProxyFactory factory2 = new ProxyFactory(handler, bridge2);
+        Object object0 = new Object();
+        Object object1 = factory1.create("", new Type(XInterface.class));
+        Object object2 = factory2.create("", new Type(XInterface.class));
+        assertNull(BridgedObject.getBridge(object0));
+        assertSame(bridge1, BridgedObject.getBridge(object1));
+        assertSame(bridge2, BridgedObject.getBridge(object2));
+    }
+
+    private static final class TestBridge implements XBridge {
+        public Object getInstance(String instanceName) {
+            return null;
+        }
+
+        public String getName() {
+            return null;
+        }
+
+        public String getDescription() {
+            return null;
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/ProxyFactory_Test.java b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/ProxyFactory_Test.java
new file mode 100644
index 000000000..45fc02f89
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/ProxyFactory_Test.java
@@ -0,0 +1,131 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.bridges.java_remote;
+
+import com.sun.star.uno.IQueryInterface;
+import com.sun.star.uno.MappingException;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XInterface;
+import com.sun.star.uno.XNamingService;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.UndeclaredThrowableException;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class ProxyFactory_Test {
+    @Test public void testQueryInterface() {
+        TestRequestHandler handler = new TestRequestHandler();
+        Type type = new Type(XNamingService.class);
+        Object proxy = new ProxyFactory(handler, null).create("TestOID", type);
+        assertSame(proxy, ((IQueryInterface) proxy).queryInterface(type));
+        assertSame(proxy, UnoRuntime.queryInterface(type, proxy));
+    }
+
+    @Test public void testExceptionHandling() throws Exception {
+        TestRequestHandler handler = new TestRequestHandler();
+        Object proxy = new ProxyFactory(handler, null).create(
+            "TestOID", new Type(XNamingService.class));
+        testExceptions(
+            handler,
+            proxy.getClass().getMethod("queryInterface",
+                                       new Class[] { Type.class }),
+            proxy, new Object[] { new Type(XInterface.class) },
+            new Class[] { null, MappingException.class,
+                          com.sun.star.uno.RuntimeException.class,
+                          UndeclaredThrowableException.class,
+                          NullPointerException.class,
+                          UndeclaredThrowableException.class });
+        testExceptions(
+            handler,
+            proxy.getClass().getMethod("getRegisteredObject",
+                                       new Class[] { String.class }),
+            proxy, new Object[] { "TestName" },
+            new Class[] { null, MappingException.class,
+                          com.sun.star.uno.RuntimeException.class,
+                          com.sun.star.uno.Exception.class,
+                          NullPointerException.class, Exception.class });
+    }
+
+    private void testExceptions(TestRequestHandler handler, Method method,
+                                Object obj, Object[] args, Class<?>[] exceptions)
+        throws Exception
+    {
+        for (int i = 0; i < exceptions.length; ++i) {
+            handler.setModus(i);
+            testExceptionType(method, obj, args, exceptions[i]);
+        }
+    }
+
+    private void testExceptionType(Method method, Object obj, Object[] args,
+            Class<?> exception) throws Exception {
+        try {
+            method.invoke(obj, args);
+            assertNull(exception);
+        } catch (InvocationTargetException e) {
+            assertNotNull(exception);
+            assertTrue(exception.isInstance(e.getTargetException()));
+            // TODO  check stack trace
+        }
+    }
+
+    private static final class TestRequestHandler implements RequestHandler {
+        public Object sendRequest(String oid, Type type, String operation,
+                                  Object[] args)
+            throws Throwable
+        {
+            if (operation.equals("release")) {
+                return null;
+            }
+            int m;
+            synchronized (lock) {
+                m = modus;
+            }
+            switch (m) {
+            case 0:
+                return operation.equals("getInstance") ? "TestResult" : null;
+            case 1:
+                // TODO  What is this test, with an obviously obsoleted
+                // MappingException, good for?
+                throw new MappingException();
+            case 2:
+                throw new com.sun.star.uno.RuntimeException();
+            case 3:
+                throw new com.sun.star.uno.Exception();
+            case 4:
+                throw new NullPointerException();
+            default:
+                throw new Throwable();
+            }
+        }
+
+        public void setModus(int modus) {
+            synchronized (lock) {
+                this.modus = modus;
+            }
+        }
+
+        private final Object lock = new Object();
+        private int modus = 0;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/java_remote_bridge_Test.java b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/java_remote_bridge_Test.java
new file mode 100644
index 000000000..53e150527
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/bridges/java_remote/java_remote_bridge_Test.java
@@ -0,0 +1,239 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.bridges.java_remote;
+
+import com.sun.star.bridge.XBridge;
+import com.sun.star.bridge.XInstanceProvider;
+import com.sun.star.comp.connections.PipedConnection;
+import com.sun.star.connection.XConnection;
+import com.sun.star.container.NoSuchElementException;
+import com.sun.star.lib.uno.environments.java.java_environment;
+import com.sun.star.lib.uno.typeinfo.MethodTypeInfo;
+import com.sun.star.lib.uno.typeinfo.TypeInfo;
+import com.sun.star.uno.IQueryInterface;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XInterface;
+import org.junit.Test;
+import util.WaitUnreachable;
+import static org.junit.Assert.*;
+
+public final class java_remote_bridge_Test {
+    @Test public void test() throws Exception {
+        String protocol = "urp";
+
+        XConnection connectionA = new PipedConnection(new Object[0]);
+        XConnection connectionB = new PipedConnection(
+            new Object[] { connectionA });
+        java_remote_bridge bridgeA = new java_remote_bridge(
+            new java_environment(null), null,
+            new Object[] { protocol, connectionA, new TestInstanceProvider() });
+        java_remote_bridge bridgeB = new java_remote_bridge(
+            new java_environment(null), null,
+            new Object[] { protocol, connectionB, null });
+
+        testGetInstance(bridgeA, bridgeB);
+        testLifeCycle(bridgeA, bridgeB);
+    }
+
+    private void testGetInstance(XBridge bridgeA, XBridge bridgeB) {
+        assertNull(bridgeB.getInstance(TestInstanceProvider.NAME_NULL));
+
+        try {
+            bridgeB.getInstance(TestInstanceProvider.NAME_RUNTIME_EXCEPTION);
+            fail("throw RuntimeException");
+        } catch (com.sun.star.uno.RuntimeException e) {
+            assertTrue(
+                e.getMessage().indexOf(
+                    TestInstanceProvider.NAME_RUNTIME_EXCEPTION)
+                != -1);
+        }
+
+        try {
+            bridgeB.getInstance(
+                TestInstanceProvider.NAME_NO_SUCH_ELEMENT_EXCEPTION);
+            fail("throw NoSuchElementException");
+        } catch (com.sun.star.uno.RuntimeException e) {
+            assertTrue(
+                e.getMessage().indexOf(
+                    TestInstanceProvider.NAME_NO_SUCH_ELEMENT_EXCEPTION)
+                != -1);
+        }
+
+        try {
+            bridgeA.getInstance(TestInstanceProvider.NAME_ANYTHING);
+            fail("no instance provider");
+        } catch (com.sun.star.uno.RuntimeException e) {
+            assertTrue(e.getMessage().startsWith("unknown OID "));
+        }
+    }
+
+    private void testLifeCycle(java_remote_bridge bridgeA,
+                               java_remote_bridge bridgeB)
+        throws InterruptedException
+    {
+        // Repeatedly, objects are mapped from bridgeA to bridgeB, where proxies
+        // for those objects (for the XInterface and TestInterface facets) are
+        // created.  The proxies at bridgeB keep both bridges alive; after those
+        // proxies have been garbage-collected, both bridges should be disposed.
+        // It does not work to map a local object from bridgeA to bridgeB, as
+        // bridgeB would find this object as a local one, too (via the shared,
+        // static localObjects Registry in java_environment): bridgeB would not
+        // create a proxy, would rather send back a "release" to bridgeA, and
+        // both bridges would be disposed while the first object is being
+        // mapped.  Therefore, a HACK is used to install TestProxy objects
+        // (which behave as if they got mapped in to bridgeA from somewhere
+        // else) at bridgeA and map those.
+
+        final int COUNT = 100;
+        XInterface[] proxyBXInterface = new XInterface[COUNT];
+        TestInterface[] proxyBTestInterface = new TestInterface[COUNT];
+        for (int i = 0; i < COUNT; ++i) {
+            String name = "TestOID" + i;
+            Object proxyA = new TestProxy(name);
+            bridgeA.getSourceEnvironment().registerInterface(
+                proxyA, new String[] { name }, new Type(XInterface.class));
+
+            proxyBXInterface[i] = (XInterface) bridgeB.getInstance(name);
+
+            // map object:
+            proxyBTestInterface[i] = UnoRuntime.queryInterface(
+                TestInterface.class, proxyBXInterface[i]);
+            proxyBTestInterface[i].function();
+
+            // remap object once:
+            TestInterface remapped = UnoRuntime.queryInterface(
+                TestInterface.class, proxyBXInterface[i]);
+            remapped.function();
+
+            // remap object twice:
+            remapped = UnoRuntime.queryInterface(
+                TestInterface.class, proxyBXInterface[i]);
+            remapped.function();
+        }
+
+        assertEquals(3 * COUNT, TestProxy.getCount());
+
+        // The following checks rely on the implementation detail that mapping
+        // different facets of a UNO object (XInterface and TestInterface) leads
+        // to different proxies:
+
+        assertEquals("bridge A life count", 2 * COUNT, bridgeA.getLifeCount());
+        assertEquals("bridge B life count", 2 * COUNT, bridgeB.getLifeCount());
+/*TODO: below test fails with "expected:<200> but was:<204>":
+        assertEquals("proxy count", 2 * COUNT, ProxyFactory.getDebugCount());
+*/
+
+        System.out.println("waiting for proxies to become unreachable:");
+        for (int i = 0; i < COUNT; ++i) {
+            WaitUnreachable u1 = new WaitUnreachable(proxyBXInterface[i]);
+            WaitUnreachable u2 = new WaitUnreachable(proxyBTestInterface[i]);
+            proxyBXInterface[i] = null;
+            proxyBTestInterface[i] = null;
+            u1.waitUnreachable();
+            u2.waitUnreachable();
+        }
+        // For whatever strange reason, this sleep seems to be necessary to
+        // reliably ensure that even the last proxy's finalization is over
+        // before the following assert is executed:
+        Thread.sleep(1000);
+
+        assertEquals("proxy count", 0, ProxyFactory.getDebugCount());
+
+        System.out.println("waiting for pending messages to be done");
+        while (bridgeA.getLifeCount() != 0 || bridgeB.getLifeCount() != 0) {
+            Thread.sleep(100);
+        }
+
+        assertEquals("Zero bridge A life count", 0, bridgeA.getLifeCount());
+        assertEquals("Zero bridge B life count", 0, bridgeB.getLifeCount());
+        assertEquals("Zero proxy count", 0, ProxyFactory.getDebugCount());
+    }
+
+    public interface TestInterface extends XInterface {
+        void function();
+
+        TypeInfo[] UNOTYPEINFO = new TypeInfo[] {
+            new MethodTypeInfo("function", 0, 0) };
+    }
+
+    private static final class TestInstanceProvider
+        implements XInstanceProvider
+    {
+        public Object getInstance(String name) throws NoSuchElementException {
+            if (name.equals(NAME_NULL)) {
+                return null;
+            } else if (name.equals(NAME_RUNTIME_EXCEPTION)) {
+                throw new com.sun.star.uno.RuntimeException(
+                    getClass().getName() + ", throwing: " + name);
+            } else if (name.equals(NAME_NO_SUCH_ELEMENT_EXCEPTION)) {
+                throw new NoSuchElementException(
+                    getClass().getName() + ", throwing: " + name);
+            } else {
+                throw new IllegalStateException();
+            }
+        }
+
+        public static final String NAME_NULL = "return null";
+        public static final String NAME_RUNTIME_EXCEPTION
+        = "throw RuntimeException";
+        public static final String NAME_NO_SUCH_ELEMENT_EXCEPTION
+        = "throw NoSuchElementException";
+        public static final String NAME_ANYTHING = "anything";
+    }
+
+    private static final class TestProxy
+        implements com.sun.star.lib.uno.Proxy, IQueryInterface,
+            TestInterface
+    {
+        public TestProxy(String oid) {
+            this.oid = oid;
+        }
+
+        public Object queryInterface(Type type) {
+            // type should be either XInterface or TestInterface...
+            return this;
+        }
+
+        public boolean isSame(Object object) {
+            return object instanceof TestProxy
+                && oid.equals(((TestProxy) object).oid);
+        }
+
+        public String getOid() {
+            return oid;
+        }
+
+        public void function() {
+            synchronized (getClass()) {
+                ++count;
+            }
+        }
+
+        public static synchronized int getCount() {
+            return count;
+        }
+
+        private final String oid;
+
+        private static int count = 0;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/java/java_environment_Test.java b/ridljar/test/com/sun/star/lib/uno/environments/java/java_environment_Test.java
new file mode 100644
index 000000000..9381e2af4
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/java/java_environment_Test.java
@@ -0,0 +1,55 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.java;
+
+import com.sun.star.uno.Type;
+import com.sun.star.uno.XInterface;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class java_environment_Test {
+    @Test public void test() {
+        java_environment env = new java_environment(null);
+
+        Object obj = Integer.valueOf(3);
+        String[] oid = new String[1];
+
+        Object obj2 = env.registerInterface(obj, oid,
+                                            new Type(XInterface.class));
+        Object obj3 = env.registerInterface(obj, oid,
+                                            new Type(XInterface.class));
+        // Register ordinary interface twice:
+        assertSame(obj, obj2);
+        assertSame(obj, obj3);
+
+        // Ask for registered interface:
+        assertSame(
+            obj,
+            env.getRegisteredInterface(oid[0], new Type(XInterface.class)));
+
+        env.revokeInterface(oid[0], new Type(XInterface.class));
+        env.revokeInterface(oid[0], new Type(XInterface.class));
+        // Revoke interface:
+        assertNull(
+            env.getRegisteredInterface(oid[0], new Type(XInterface.class)));
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/JavaThreadPoolFactory_Test.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/JavaThreadPoolFactory_Test.java
new file mode 100644
index 000000000..2d2264f06
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/JavaThreadPoolFactory_Test.java
@@ -0,0 +1,48 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class JavaThreadPoolFactory_Test {
+    @Test public void test() throws InterruptedException {
+        ThreadId i1 = JavaThreadPoolFactory.getThreadId();
+        assertEquals(i1, JavaThreadPoolFactory.getThreadId());
+        final ThreadId[] i2 = new ThreadId[1];
+        new Thread() {
+            @Override
+            public void run() {
+                synchronized (i2) {
+                    i2[0] = JavaThreadPoolFactory.getThreadId();
+                    i2.notify();
+                }
+            }
+        }.start();
+        synchronized (i2) {
+            while (i2[0] == null) {
+                i2.wait();
+            }
+        }
+        assertFalse(i1.equals(i2[0]));
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/JobQueue_Test.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/JobQueue_Test.java
new file mode 100644
index 000000000..a63c9c7ed
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/JobQueue_Test.java
@@ -0,0 +1,263 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+import com.sun.star.lib.uno.typedesc.TypeDescription;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class JobQueue_Test {
+    @Test public void testThreadLeavesJobQueueOnDispose0()
+        throws InterruptedException
+    {
+        testThreadLeavesJobQueueOnDispose(0);
+    }
+
+    @Test public void testThreadLeavesJobQueueOnDispose5000()
+        throws InterruptedException
+    {
+        testThreadLeavesJobQueueOnDispose(5000);
+    }
+
+    private void testThreadLeavesJobQueueOnDispose(int waitTime)
+        throws InterruptedException
+    {
+        TestThread t = new TestThread(waitTime);
+        t.waitToStart();
+        String msg = "xcxxxxxxxx";
+        t._jobQueue.dispose(t._disposeId, new RuntimeException (msg));
+        t.waitToTerminate();
+/*TODO: below test fails with "expected:<xcxxxxxxxx> but was:<null>":
+        assertEquals(msg, t._message);
+*/
+    }
+
+    @Test public void testThreadLeavesJobQueueOnReply0()
+        throws InterruptedException
+    {
+        testThreadLeavesJobQueueOnReply(0);
+    }
+
+    @Test public void testThreadLeavesJobQueueOnReply5000()
+        throws InterruptedException
+    {
+        testThreadLeavesJobQueueOnReply(5000);
+    }
+
+    private void testThreadLeavesJobQueueOnReply(int waitTime)
+        throws InterruptedException
+    {
+        TestThread t = new TestThread(waitTime);
+        t.waitToStart();
+        // put reply job:
+        t._jobQueue.putJob(
+            new Job(null, __iReceiver,
+                    new Message(
+                        null, false, "oid", __workAt_td, null, false, null,
+                        false, null, null)),
+            null);
+        t.waitToTerminate();
+        assertTrue(true); // TODO! ???
+    }
+
+    @Test public void testStaticThreadExecutesJobs0()
+        throws InterruptedException
+    {
+        testStaticThreadExecutesJobs(0);
+    }
+
+    @Test public void testStaticThreadExecutesJobs5000()
+        throws InterruptedException
+    {
+        testStaticThreadExecutesJobs(5000);
+    }
+
+    private void testStaticThreadExecutesJobs(int waitTime)
+        throws InterruptedException
+    {
+        TestThread t = new TestThread(waitTime);
+        t.waitToStart();
+        testExecuteJobs(t._jobQueue);
+        t._jobQueue.dispose(t._disposeId,
+                            new RuntimeException("xxxxxxxxxxxxx"));
+        t.waitToTerminate();
+    }
+
+    @Test public void testDynamicThreadExecutesJob() throws InterruptedException
+    {
+        testExecuteJobs(
+            new JobQueue(
+                __javaThreadPoolFactory, ThreadId.createFresh(), true));
+    }
+
+    @Test public void testStaticThreadExecutesAsyncs()
+        throws InterruptedException
+    {
+        TestThread t = new TestThread();
+        JobQueue async_jobQueue = new JobQueue(__javaThreadPoolFactory,
+                                               t._threadId);
+        assertEquals(1, async_jobQueue._ref_count);
+        t._jobQueue = __javaThreadPoolFactory.getJobQueue(t._threadId);
+        assertEquals(1, t._jobQueue._ref_count);
+        t.waitToStart();
+        TestWorkAt workAt = new TestWorkAt();
+        testAsyncJobQueue(workAt, async_jobQueue, t._threadId);
+        t._jobQueue.dispose(t._disposeId,
+                            new RuntimeException("xxxxxxxxxxxxx"));
+        t.waitToTerminate();
+        assertEquals(TestWorkAt.MESSAGES, workAt._async_counter);
+        assertEquals(TestWorkAt.MESSAGES, workAt._sync_counter);
+    }
+
+    @Test public void testDynamicThreadExecutesAsyncs()
+        throws InterruptedException
+    {
+        ThreadId threadId = ThreadId.createFresh();
+        JobQueue async_jobQueue = new JobQueue(__javaThreadPoolFactory,
+                                               threadId);
+        TestWorkAt workAt = new TestWorkAt();
+        testAsyncJobQueue(workAt, async_jobQueue, threadId);
+        assertEquals(TestWorkAt.MESSAGES, workAt._async_counter);
+        assertEquals(TestWorkAt.MESSAGES, workAt._sync_counter);
+    }
+
+    private void testExecuteJobs(JobQueue jobQueue) throws InterruptedException
+    {
+        TestWorkAt workAt = new TestWorkAt();
+        testSendRequests(workAt, "increment", jobQueue);
+        synchronized (workAt) {
+            jobQueue.putJob(new Job(workAt, __iReceiver,
+                                    new Message(
+                                        null, true, "oid", __workAt_td,
+                                        __workAt_td.getMethodDescription(
+                                             "notifyme"),
+                                        true, null, false, null, null)),
+                            null);
+            while (!workAt._notified) {
+                workAt.wait();
+            }
+        }
+        assertEquals(TestWorkAt.MESSAGES, workAt._counter);
+    }
+
+    private void testAsyncJobQueue(TestWorkAt workAt, JobQueue async_jobQueue,
+                                   ThreadId threadId)
+        throws InterruptedException
+    {
+        // put slow async calls first, followed by fast sync calls:
+        testSendRequests(workAt, "asyncCall", async_jobQueue);
+        testSendRequests(workAt, "syncCall",
+                         __javaThreadPoolFactory.getJobQueue(threadId));
+        synchronized (workAt) {
+            async_jobQueue._sync_jobQueue.putJob(
+                new Job(workAt, __iReceiver,
+                        new Message(
+                            null, true, "oid", __workAt_td,
+                            __workAt_td.getMethodDescription("notifyme"),
+                            true, null, false, null, null)),
+                null);
+            while (!workAt._notified) {
+                workAt.wait();
+            }
+        }
+        assertTrue(workAt.passedAsyncTest());
+    }
+
+    private void testSendRequests(TestWorkAt workAt, String operation,
+                                  JobQueue jobQueue) {
+        Message iMessage = new Message(
+            null, true, "oid", __workAt_td,
+            __workAt_td.getMethodDescription(operation),
+            true, null, false, null, null);
+        for (int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            jobQueue.putJob(new Job(workAt, __iReceiver, iMessage),
+                            new Object());
+        }
+    }
+
+    private static final class TestThread extends Thread {
+        public final ThreadId _threadId = JavaThreadPoolFactory.getThreadId();
+        public final Object _disposeId = new Object();
+        public JobQueue _jobQueue = null;
+
+        public TestThread(int waitTime) {
+            this.waitTime = waitTime;
+            _jobQueue = new JobQueue(__javaThreadPoolFactory, _threadId, false);
+        }
+
+        public TestThread() {
+            waitTime = 0;
+        }
+
+        @Override
+        public void run() {
+            synchronized (lock) {
+                state = STATE_STARTED;
+                lock.notifyAll();
+            }
+            try {
+                if (waitTime != 0) {
+                    Thread.sleep(waitTime);
+                }
+                _jobQueue.enter(_disposeId);
+            } catch (Throwable e) {
+            }
+            synchronized (lock) {
+                state = STATE_DONE;
+                lock.notifyAll();
+            }
+        }
+
+        public void waitToStart() throws InterruptedException {
+            start();
+            synchronized (lock) {
+                while (state == STATE_INITIAL) {
+                    lock.wait();
+                }
+            }
+        }
+
+        public void waitToTerminate() throws InterruptedException {
+            synchronized (lock) {
+                while (state != STATE_DONE) {
+                    lock.wait();
+                }
+            }
+            join();
+        }
+
+        private final int waitTime;
+
+        private final Object lock = new Object();
+        private int state = STATE_INITIAL;
+        private static final int STATE_INITIAL = 0;
+        private static final int STATE_STARTED = 1;
+        private static final int STATE_DONE = 2;
+    }
+
+    private static final JavaThreadPoolFactory __javaThreadPoolFactory
+    = new JavaThreadPoolFactory();
+    private static final IReceiver __iReceiver = new TestReceiver();
+    private static final TypeDescription __workAt_td
+    = TypeDescription.getTypeDescription(TestIWorkAt.class);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/TestIWorkAt.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestIWorkAt.java
new file mode 100644
index 000000000..7bb71a80e
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestIWorkAt.java
@@ -0,0 +1,43 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+
+import com.sun.star.lib.uno.typeinfo.MethodTypeInfo;
+import com.sun.star.lib.uno.typeinfo.TypeInfo;
+import com.sun.star.uno.XInterface;
+
+public interface TestIWorkAt extends XInterface {
+    void syncCall() throws Throwable ;
+    void asyncCall() throws Throwable ;
+
+    void increment() throws Throwable;
+
+    void notifyme();
+
+    TypeInfo UNOTYPEINFO[] = {
+        new MethodTypeInfo("increment", 0, 0),
+        new MethodTypeInfo("notifyme", 1, 0),
+        new MethodTypeInfo("syncCall", 2, 0),
+        new MethodTypeInfo("asyncCall", 3, 0)
+            };
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/TestReceiver.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestReceiver.java
new file mode 100644
index 000000000..6c8f36885
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestReceiver.java
@@ -0,0 +1,27 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+final class TestReceiver implements IReceiver {
+    public void sendReply(boolean exception, ThreadId threadId, Object result) {
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/TestWorkAt.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestWorkAt.java
new file mode 100644
index 000000000..93297815c
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/TestWorkAt.java
@@ -0,0 +1,81 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+import static org.junit.Assert.*;
+
+class TestWorkAt implements TestIWorkAt {
+    /**
+     * When set to true, enables various debugging output.
+     */
+    private static final boolean DEBUG = false;
+
+    static final int MESSAGES = 35;
+
+
+    int _counter;
+
+    int _sync_counter;
+    int _async_counter;
+
+    private boolean _passedAsync = true;
+    boolean _notified = false;
+
+    public synchronized void syncCall() throws Throwable {
+        ++ _sync_counter;
+
+        // at least in currently run tests this should never fire, so don't
+        // defer the check until passedAsyncTest and assert here
+        assertEquals(MESSAGES, _async_counter);
+        if(_async_counter != MESSAGES)
+            _passedAsync = false;
+
+        if(DEBUG) System.err.println("syncCall:" + _sync_counter + " " + _passedAsync + " " + Thread.currentThread());
+    }
+
+    public synchronized void asyncCall() throws Throwable {
+        ++ _async_counter;
+
+        if(DEBUG) System.err.println("asyncCall:" + _async_counter + " " + Thread.currentThread());
+    }
+
+    public synchronized void increment() throws Throwable {
+        if(DEBUG) System.err.println("increment - " + Thread.currentThread());
+
+        ++ _counter;
+        notifyAll();
+    }
+
+    public synchronized void notifyme() {
+        if(DEBUG) System.err.println("\t\t\tnotifying me" + Thread.currentThread());
+
+        notifyAll();
+
+        _notified = true;
+    }
+
+    public synchronized boolean passedAsyncTest() {
+        assertEquals(MESSAGES, _sync_counter);
+        assertTrue(_passedAsync);
+        return  _passedAsync && (_sync_counter == MESSAGES);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadId_Test.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadId_Test.java
new file mode 100644
index 000000000..8ee7f4a4c
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadId_Test.java
@@ -0,0 +1,57 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+import java.util.Arrays;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class ThreadId_Test {
+    @Test public void test() {
+        ThreadId i1 = ThreadId.createFresh();
+        assertTrue(i1.equals(i1));
+        assertFalse(i1.equals(null));
+        assertFalse(i1.equals(new Object()));
+        assertEquals(i1.hashCode(), i1.hashCode());
+        byte[] i1bytes = i1.getBytes();
+        assertNotNull(i1bytes);
+        assertTrue(i1bytes.length >= 5);
+        assertEquals('j', i1bytes[0]);
+        assertEquals('a', i1bytes[1]);
+        assertEquals('v', i1bytes[2]);
+        assertEquals('a', i1bytes[3]);
+        assertEquals(':', i1bytes[4]);
+        assertArrayEquals(i1bytes, i1.getBytes());
+
+        ThreadId i2 = ThreadId.createFresh();
+        assertFalse(i1.equals(i2));
+        assertFalse(i2.equals(i1));
+        assertFalse(Arrays.equals(i1bytes, i2.getBytes()));
+
+        ThreadId i3 = new ThreadId(i1bytes);
+        assertTrue(i3.equals(i1));
+        assertFalse(i3.equals(i2));
+        assertTrue(i1.equals(i3));
+        assertEquals(i1.hashCode(), i3.hashCode());
+        assertArrayEquals(i1bytes, i3.getBytes());
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadPool_Test.java b/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadPool_Test.java
new file mode 100644
index 000000000..7da68db23
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/environments/remote/ThreadPool_Test.java
@@ -0,0 +1,437 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.environments.remote;
+
+import com.sun.star.lib.uno.typedesc.MethodDescription;
+import com.sun.star.lib.uno.typedesc.TypeDescription;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class ThreadPool_Test {
+    @Test public void testDispose() throws InterruptedException {
+        IThreadPool iThreadPool = ThreadPoolManager.create();
+        TestThread testThread = new TestThread(iThreadPool);
+
+        ThreadId threadId = null;
+
+        // start the test thread
+        synchronized(testThread) {
+            testThread.start();
+
+            testThread.wait();
+
+            threadId = testThread._threadId;
+
+            // let the thread attach and enter the threadpool
+            testThread.notifyAll();
+        }
+
+        String message = "blabla";
+
+        // terminate the test thread
+        synchronized(testThread) {
+            // put reply job
+            iThreadPool.dispose(new RuntimeException(message));
+
+            testThread.wait();
+        }
+
+        testThread.join();
+
+/*TODO: below test fails with "expected:<blabla> but was:<null>":
+        assertEquals(message, testThread._message);
+*/
+    }
+
+    @Test public void testThreadAsync() throws InterruptedException {
+        TestWorkAt workAt = new TestWorkAt();
+
+        ThreadId threadId = ThreadId.createFresh();
+
+        // queue asyncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, false, threadId, "increment");
+        }
+
+        synchronized(workAt) {
+            putJob(workAt, false, threadId, "notifyme");
+
+            while(!workAt._notified) {
+                workAt.wait();
+            }
+        }
+
+        assertEquals(TestWorkAt.MESSAGES, workAt._counter);
+    }
+
+    @Test public void testDynamicThreadSync() throws InterruptedException {
+        TestWorkAt workAt = new TestWorkAt();
+
+        ThreadId threadId = ThreadId.createFresh();
+
+        // queue asyncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, true, threadId, "increment");
+        }
+
+        synchronized(workAt) {
+            putJob(workAt, true, threadId, "notifyme");
+
+            while(!workAt._notified) {
+                workAt.wait();
+            }
+        }
+
+        assertEquals(TestWorkAt.MESSAGES, workAt._counter);
+    }
+
+    @Test public void testStaticThreadSync() throws InterruptedException {
+        TestWorkAt workAt = new TestWorkAt();
+
+        TestThread testThread = new TestThread();
+
+        ThreadId threadId = null;
+
+        // start the test thread
+        synchronized(testThread) {
+            testThread.start();
+
+            testThread.wait();
+
+            threadId = testThread._threadId;
+
+            // let the thread attach and enter the threadpool
+            testThread.notifyAll();
+        }
+
+        // queue syncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, true, threadId, "increment");
+        }
+
+        // terminate the test thread
+        synchronized(testThread) {
+            // put reply job
+            putJob(workAt, true, threadId, null);
+
+            testThread.wait();
+        }
+
+        testThread.join();
+
+        assertEquals(TestWorkAt.MESSAGES, workAt._counter);
+    }
+
+    @Test public void testDynamicThreadAsyncSyncOrder()
+        throws InterruptedException
+    {
+        TestWorkAt workAt = new TestWorkAt();
+
+        ThreadId threadId = ThreadId.createFresh();
+
+        // queue asyncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, false, threadId, "asyncCall");
+        }
+
+        // queue syncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, true, threadId, "syncCall");
+        }
+
+        synchronized(workAt) {
+            putJob(workAt, true, threadId, "notifyme");
+
+            while(!workAt._notified) {
+                workAt.wait();
+            }
+        }
+
+        assertTrue(workAt.passedAsyncTest());
+    }
+
+    @Test public void testStaticThreadAsyncSyncOrder()
+        throws InterruptedException
+    {
+        TestWorkAt workAt = new TestWorkAt();
+
+        TestThread testThread = new TestThread();
+
+        // start the test thread
+        synchronized(testThread) {
+            testThread.start();
+
+            testThread.wait();
+        }
+
+        ThreadId threadId = testThread._threadId;
+
+        // queue asyncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, false, threadId, "asyncCall");
+        }
+
+        // let the thread attach and enter the threadpool
+        synchronized(testThread) {
+            testThread.notifyAll();
+        }
+
+        // queue syncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            Thread.yield(); // force scheduling
+            putJob(workAt, true, threadId, "syncCall");
+        }
+
+        // terminate the test thread
+        synchronized(testThread) {
+            // put reply job
+            putJob(workAt, true, threadId, null);
+
+            testThread.wait();
+        }
+
+        testThread.join();
+
+        assertTrue(workAt.passedAsyncTest());
+    }
+
+    @Test public void testStress() throws InterruptedException {
+        TestWorkAt workAt = new TestWorkAt();
+        for (int i = 0; i < TestWorkAt.MESSAGES; ++i) {
+            Thread.yield(); // force scheduling
+            ThreadId threadID = ThreadId.createFresh();
+            putJob(workAt, true, threadID, "increment");
+            putJob(workAt, false, threadID, "increment");
+        }
+        synchronized (workAt) {
+            while (workAt._counter < 2 * TestWorkAt.MESSAGES) {
+                workAt.wait();
+            }
+        }
+
+        abstract class Stress extends Thread {
+            private Stress(int count) {
+                this.count = count;
+            }
+
+            @Override
+            public void run() {
+                try {
+                    for (int i = 0; i < count; ++i) {
+                        runTest();
+                    }
+                } catch (Throwable e) {
+                    e.printStackTrace(System.err);
+                }
+            }
+
+            protected abstract void runTest() throws InterruptedException;
+
+            private final int count;
+        }
+
+        Stress stress1 = new Stress(50) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testThreadAsync();
+                }
+            };
+        stress1.start();
+
+        Stress stress2 = new Stress(50) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testDynamicThreadSync();
+                }
+            };
+        stress2.start();
+
+        Stress stress3 = new Stress(50) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testStaticThreadSync();
+                }
+            };
+        stress3.start();
+
+        Stress stress4 = new Stress(50) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testDynamicThreadAsyncSyncOrder();
+                }
+            };
+        stress4.start();
+
+        Stress stress5 = new Stress(50) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testStaticThreadAsyncSyncOrder();
+                }
+            };
+        stress5.start();
+
+        Stress stress6 = new Stress(500) {
+                @Override
+                protected void runTest() throws InterruptedException {
+                    testDispose();
+                }
+            };
+        stress6.start();
+
+        stress1.join();
+        stress2.join();
+        stress3.join();
+        stress4.join();
+        stress5.join();
+        stress6.join();
+    }
+
+    @Test public void testAsyncSync() throws InterruptedException {
+        TestWorkAt workAt = new TestWorkAt();
+        ThreadId threadId = ThreadId.createFresh();
+        MyWorkAt myWorkAt = new MyWorkAt( workAt );
+
+        // queue asyncs
+        for(int i = 0; i < TestWorkAt.MESSAGES; ++ i) {
+            if( i == 2 )
+            {
+                putJob( myWorkAt, false , threadId, "asyncCall" );
+            }
+            putJob(workAt, false, threadId, "asyncCall");
+        }
+
+        synchronized(workAt) {
+            putJob(workAt, false, threadId, "notifyme");
+
+            while(!workAt._notified) {
+                workAt.wait();
+            }
+        }
+
+        assertEquals(TestWorkAt.MESSAGES, workAt._async_counter);
+        assertTrue(myWorkAt._success);
+    }
+
+    private static void putJob(TestIWorkAt iWorkAt, boolean synchron,
+                               ThreadId threadId, String operation) {
+        __iThreadPool.putJob(
+            new Job(iWorkAt, __iReceiver,
+                    new Message(
+                        threadId, operation != null, "oid", __workAt_td,
+                        (operation == null
+                         ? null
+                         : ((MethodDescription)
+                            __workAt_td.getMethodDescription(operation))),
+                        synchron, null, false, null, null)));
+    }
+
+    private static final class TestThread extends Thread {
+        ThreadId _threadId;
+        IThreadPool _iThreadPool;
+
+        TestThread() {
+            this(__iThreadPool);
+        }
+
+        TestThread(IThreadPool iThreadPool) {
+            _iThreadPool = iThreadPool;
+        }
+
+        @Override
+        public void run() {
+            _threadId = _iThreadPool.getThreadId();
+
+
+            try {
+                synchronized(this) {
+                    // notify that we are running
+                    notify();
+
+                    _iThreadPool.attach();
+
+                    // wait until we should continue
+                    wait();
+                }
+
+                _iThreadPool.enter();
+            }
+            catch(Throwable throwable) {
+            }
+
+            _iThreadPool.detach();
+
+            synchronized(this) {
+                // notify the listeners that we are dying
+                notifyAll();
+            }
+        }
+    }
+
+    private static final class MyWorkAt implements TestIWorkAt {
+        public MyWorkAt( TestWorkAt async_WorkAt ) {
+            _async_WorkAt = async_WorkAt;
+        }
+
+        public void syncCall() throws Throwable
+        {
+            Message iMessage = new Message(
+                __iThreadPool.getThreadId(), false, "oid", __workAt_td, null,
+                false, null, false, null, null);
+
+            // marshal reply
+            ThreadPool_Test.__iThreadPool.putJob(
+                new Job(this, ThreadPool_Test. __iReceiver, iMessage));
+        }
+
+        public  void asyncCall() throws Throwable {
+            for (int i = 0 ; i < 5 ; ++i) {
+                ThreadPool_Test.__iThreadPool.attach();
+                ThreadPool_Test.putJob(this, true, __iThreadPool.getThreadId(),
+                                       "syncCall");
+                // wait for reply
+                ThreadPool_Test.__iThreadPool.enter();
+                ThreadPool_Test.__iThreadPool.detach();
+            }
+            // async must have waited for this call
+            _success = _async_WorkAt._async_counter == 2;
+        }
+
+        public void increment() throws Throwable {}
+
+        public void notifyme() {}
+
+        public boolean _success = false;
+
+        private final TestWorkAt _async_WorkAt;
+    }
+
+    private static final IThreadPool __iThreadPool = ThreadPoolManager.create();
+    private static final IReceiver __iReceiver = new TestReceiver();
+    private static final TypeDescription __workAt_td
+    = TypeDescription.getTypeDescription(TestIWorkAt.class);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/Cache_Test.java b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Cache_Test.java
new file mode 100644
index 000000000..a7d93733d
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Cache_Test.java
@@ -0,0 +1,134 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.protocols.urp;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class Cache_Test {
+    @Test public void test0() {
+        Cache c = new Cache(0);
+        boolean[] f = new boolean[1];
+        int i;
+        i = c.add(f, "a");
+        assertTrue(i == Cache.NOT_CACHED && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == Cache.NOT_CACHED && !f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == Cache.NOT_CACHED && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == Cache.NOT_CACHED && !f[0]);
+    }
+
+    @Test public void test1() {
+        Cache c = new Cache(1);
+        boolean[] f = new boolean[1];
+        int i;
+        i = c.add(f, "a");
+        assertTrue(i == 0 && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 0 && !f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && !f[0]);
+    }
+
+    @Test public void test2() {
+        Cache c = new Cache(2);
+        boolean[] f = new boolean[1];
+        int i;
+        i = c.add(f, "a");
+        assertTrue(i == 0 && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 1 && !f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 1 && f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "c");
+        assertTrue(i == 1 && !f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 0 && !f[0]);
+    }
+
+    @Test public void test3() {
+        Cache c = new Cache(3);
+        boolean[] f = new boolean[1];
+        int i;
+        i = c.add(f, "a");
+        assertTrue(i == 0 && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "b");
+        assertTrue(i == 1 && !f[0]);
+        i = c.add(f, "a");
+        assertTrue(i == 0 && f[0]);
+        i = c.add(f, "c");
+        assertTrue(i == 2 && !f[0]);
+        i = c.add(f, "d");
+        assertTrue(i == 1 && !f[0]);
+        i = c.add(f, "d");
+        assertTrue(i == 1 && f[0]);
+    }
+
+    @Test public void testNothingLostFromLruList() {
+        // Regardless in what order arbitrary values from 0, ..., 3 are inserted
+        // into a size-4 cache, afterwards adding -1, ..., -4 must return each
+        // possible index in the range from 0, ..., 3 exactly once (so their sum
+        // must be 6); this code systematically tests all such arbitrary ways up
+        // to length 8 (the code arguably violates recommendations for writing
+        // good tests, but actually helped track down an error in the Cache
+        // implementation):
+        int[] a = new int[8];
+        for (int i = 0; i < a.length; ++i) {
+            for (int j = 0; j < i; ++j) {
+                a[j] = 0;
+            }
+            for (;;) {
+                Cache c = new Cache(4);
+                for (int k = 0; k < i; ++k) {
+                    c.add(new boolean[1], a[k]);
+                }
+                assertEquals(
+                    6,
+                    (c.add(new boolean[1], -1) + c.add(new boolean[1], -2) +
+                     c.add(new boolean[1], -3) + c.add(new boolean[1], -4)));
+                int j = i - 1;
+                while (j >= 0 && a[j] == 3) {
+                    --j;
+                }
+                if (j < 0) {
+                    break;
+                }
+                ++a[j];
+                for (int k = j + 1; k < i; ++k) {
+                    a[k] = 0;
+                }
+            }
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/Marshaling_Test.java b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Marshaling_Test.java
new file mode 100644
index 000000000..5cf5f73e6
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Marshaling_Test.java
@@ -0,0 +1,353 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.protocols.urp;
+
+import com.sun.star.lib.uno.typedesc.TypeDescription;
+import com.sun.star.uno.Any;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.TypeClass;
+import com.sun.star.uno.XInterface;
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class Marshaling_Test {
+    @Test public void test() throws Exception {
+        short cacheSize = (short)256;
+        TestBridge testBridge = new TestBridge();
+        Marshal marshal = new Marshal(testBridge, cacheSize);
+
+        TestObject testObject = new TestObject();
+
+        TestPrimitiveSeqStruct x = new TestPrimitiveSeqStruct();
+        x.zAny = new Object[]{Integer.valueOf(1), new Double(2) };
+
+
+        Object data[] = new Object[] {
+            new com.sun.star.uno.RuntimeException("testRuntimeException"),
+            new com.sun.star.uno.Exception("testException"),
+            Boolean.TRUE,
+            Byte.valueOf((byte)47),
+            new Character('k'),
+            new Double(0.12345),
+            TestEnum.B,
+            new Float(0.5678),
+            Integer.valueOf(0),
+            Integer.valueOf(128),
+            Integer.valueOf(0x0f00),
+            Integer.valueOf(0x0f0000),
+            Integer.valueOf(0x0f000000),
+            Integer.valueOf(-128),
+            Integer.valueOf(0xff00),
+            Integer.valueOf(0xff0000),
+            Integer.valueOf(0xff000000),
+            Long.valueOf(666L),
+            Short.valueOf((short)444),
+            "blabla",
+            Integer.valueOf(10),  // Any as object
+            Integer.valueOf(10),  // Any as object
+            new Any(new Type(Integer.class), Integer.valueOf(10)), // Any as Any
+            new Any(new Type(Integer.class), Integer.valueOf(10)), // Any as Any
+            null,
+            new TestPrimitiveStruct(),
+            x,
+            new byte[]{1,2,3,4,5,6,7}, // primitive sequence
+            new int[]{7,6,5,4,3,2,1}, // primitive sequence
+            new Object[]{Integer.valueOf(123), "hallo"}, // any sequence
+            new TestPrimitiveStruct[]{new TestPrimitiveStruct(), new TestPrimitiveStruct()}, // sequence of primitive structs
+            new TestPrimitiveSeqStruct[]{new TestPrimitiveSeqStruct(), new TestPrimitiveSeqStruct()}, // sequence of primitive structs
+            new TestNestedStruct(),
+            new TestNestedSeqStruct(),
+            new Type(Void.class),
+            new Type(String.class),
+            new Type(Object.class),
+            new Type(Byte.class),
+            new Type(Integer.class),
+            new Type(Double.class),
+            new Type(Float.class),
+            new Type(Character.class),
+            new Type(Short.class),
+            new Type(Boolean.class),
+            new Type(void.class),
+            new Type(byte.class),
+            new Type(int.class),
+            new Type(double.class),
+            new Type(float.class),
+            new Type(char.class),
+            new Type(short.class),
+            new Type(boolean.class),
+            new Type(Class.forName("[Ljava.lang.String;")),
+            new Type(Class.forName("[Ljava.lang.Object;")),
+            new Type(Class.forName("[B")),
+            new Type(Class.forName("[Z")),
+            new Type("boolean"),
+            new Type("byte"),
+            new Type("char"),
+            new Type("short"),
+            new Type("long"),
+            new Type("hyper"),
+            new Type("float"),
+            new Type("double"),
+            new Type("string"),
+            new Type("void"),
+            new Type("any"),
+            new Type(
+                "com.sun.star.lib.uno.protocols.urp.TestEnum", TypeClass.ENUM),
+            new Type("[]boolean", TypeClass.SEQUENCE),
+            new Type("[][]byte", TypeClass.SEQUENCE),
+            new Type("[][][]char", TypeClass.SEQUENCE),
+            new Type("[][][][]short", TypeClass.SEQUENCE),
+            new Type("[][][][][]any", TypeClass.SEQUENCE),
+            new Type("com.sun.star.uno.XInterface", TypeClass.INTERFACE),
+            new Type("[]com.sun.star.uno.XInterface", TypeClass.SEQUENCE),
+            testObject,
+            testObject,
+            new TestInterfaceStruct(testObject, null)
+        };
+
+        TypeDescription dataTypes[] = new TypeDescription[] {
+            TypeDescription.getTypeDescription(com.sun.star.uno.RuntimeException.class),
+            TypeDescription.getTypeDescription(com.sun.star.uno.Exception.class),
+            TypeDescription.getTypeDescription(Boolean.class),
+            TypeDescription.getTypeDescription(Byte.class),
+            TypeDescription.getTypeDescription(Character.class),
+            TypeDescription.getTypeDescription(Double.class),
+            TypeDescription.getTypeDescription(TestEnum.class),
+            TypeDescription.getTypeDescription(Float.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Integer.class),
+            TypeDescription.getTypeDescription(Long.class),
+            TypeDescription.getTypeDescription(Short.class),
+            TypeDescription.getTypeDescription(String.class),
+            TypeDescription.getTypeDescription(Object.class),
+            TypeDescription.getTypeDescription(Any.class),
+            TypeDescription.getTypeDescription(Any.class),
+            TypeDescription.getTypeDescription(Object.class),
+            TypeDescription.getTypeDescription(XInterface.class),
+            TypeDescription.getTypeDescription(TestPrimitiveStruct.class),
+            TypeDescription.getTypeDescription(TestPrimitiveSeqStruct.class),
+            TypeDescription.getTypeDescription(Class.forName("[B")),
+            TypeDescription.getTypeDescription(Class.forName("[I")),
+            TypeDescription.getTypeDescription(Class.forName("[Lcom.sun.star.uno.Any;")),
+            TypeDescription.getTypeDescription(
+                Class.forName(
+                    "[Lcom.sun.star.lib.uno.protocols.urp."
+                    + "TestPrimitiveStruct;")),
+            TypeDescription.getTypeDescription(
+                Class.forName(
+                    "[Lcom.sun.star.lib.uno.protocols.urp."
+                    + "TestPrimitiveSeqStruct;")),
+            TypeDescription.getTypeDescription(TestNestedStruct.class),
+            TypeDescription.getTypeDescription(TestNestedSeqStruct.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(Type.class),
+            TypeDescription.getTypeDescription(XInterface.class),
+            TypeDescription.getTypeDescription(XInterface.class),
+            TypeDescription.getTypeDescription(TestInterfaceStruct.class),
+        };
+
+
+        Unmarshal unmarshal = new Unmarshal(testBridge, cacheSize);
+        for(int i = 0; i < dataTypes.length; ++ i) {
+            Object op1 = data[i];
+            marshal.writeValue(dataTypes[i], data[i]);
+
+            unmarshal.reset(marshal.reset());
+
+            Object op2 = unmarshal.readValue(dataTypes[i]);
+
+            if(op1 instanceof Any)
+                op1 = ((Any)op1).getObject();
+
+            assertTrue(compareObjects(op1, op2));
+        }
+    }
+
+    private static boolean compareArrays(Object op1, Object op2) throws Exception {
+        boolean result = true;
+        if((op1.getClass().getComponentType() == op2.getClass().getComponentType())
+           && (Array.getLength(op1) == Array.getLength(op2)))
+        {
+            for(int i = 0; i < Array.getLength(op1); ++ i)
+                result = result & compareObjects(Array.get(op1, i), Array.get(op2, i));
+        }
+
+        return result;
+    }
+
+    private static boolean compareInterfaces(XInterface op1, XInterface op2) {
+        return op1 == op2;
+    }
+
+    private static boolean compareStructs(Class zClass, Object op1, Object op2) throws Exception {
+        boolean result = true;
+
+        Field fields[] = zClass.getFields();
+
+        for(int i = 0; i < fields.length && result; ++ i) {
+            if((fields[i].getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { // neither static nor transient ?
+                result = result & compareObjects(fields[i].get(op1), fields[i].get(op2));
+
+                if(!result)
+                    System.err.println("blabal :" + fields[i]);
+            }
+        }
+
+        return result;
+    }
+
+    private static boolean compareStructs(Object op1, Object op2) throws Exception {
+        boolean result = true;
+
+        if(op1.getClass() != op2.getClass())
+            result = false;
+        else {
+            result = compareStructs(op1.getClass(), op1, op2);
+        }
+
+        return result;
+    }
+
+    private static boolean compareThrowable(Throwable op1, Throwable op2) throws Exception {
+        boolean result = true;
+
+        if(op1.getClass() != op2.getClass())
+            result = false;
+        else {
+            result = compareStructs(op1.getClass(), op1, op2);
+
+            result = result & op1.getMessage().equals(op2.getMessage());
+        }
+
+        return result;
+    }
+
+    private static boolean compareObjects(Object op1, Object op2) throws Exception {
+        boolean result = false;
+
+        if(op1 == op2)
+            result = true;
+
+        else if(op1.getClass().isPrimitive() && op2.getClass().isPrimitive())
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Byte.class && op2.getClass() == Byte.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Type.class && op2.getClass() == Type.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Boolean.class && op2.getClass() == Boolean.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Short.class && op2.getClass() == Short.class)
+            result = op1.equals(op2);
+
+        else if(Throwable.class.isAssignableFrom(op1.getClass()) && Throwable.class.isAssignableFrom(op2.getClass()))
+            result = compareThrowable((Throwable)op1, (Throwable)op2);
+
+        else if(op1.getClass() == Integer.class && op2.getClass() == Integer.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Character.class && op2.getClass() == Character.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Long.class && op2.getClass() == Long.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Void.class && op2.getClass() == Void.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Float.class && op2.getClass() == Float.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass() == Double.class && op2.getClass() == Double.class)
+            result = op1.equals(op2);
+
+        else if(op1.getClass().isArray() && op2.getClass().isArray())
+            result = compareArrays(op1, op2);
+
+        else if(op1.getClass() == Void.class || op2.getClass() == void.class) // write nothing ?
+            result = true;
+
+        else if(XInterface.class.isAssignableFrom(op1.getClass()) && XInterface.class.isAssignableFrom(op2.getClass()))
+            result = compareInterfaces((XInterface)op1, (XInterface)op2);
+
+        else if(op1.getClass() == String.class && op2.getClass() == String.class) // is it a String ?
+            result = ((String)op1).equals(op2);
+
+        else if(op1.getClass() == Type.class && op2.getClass() == Type.class) // types?
+            result = op1.equals(op2);
+
+        else // otherwise it must be a struct
+            result = compareStructs(op1, op2);
+
+        return result;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/Protocol_Test.java b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Protocol_Test.java
new file mode 100644
index 000000000..cda58aad8
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/Protocol_Test.java
@@ -0,0 +1,311 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.protocols.urp;
+
+import com.sun.star.lib.uno.environments.remote.Message;
+import com.sun.star.lib.uno.environments.remote.IProtocol;
+import com.sun.star.lib.uno.environments.remote.ThreadId;
+import com.sun.star.lib.uno.typedesc.TypeDescription;
+import com.sun.star.uno.Any;
+import com.sun.star.uno.IBridge;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.XInterface;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+import java.util.LinkedList;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class Protocol_Test {
+    @Test public void test() throws Exception {
+        IBridge iBridge = new TestBridge();
+        PipedInputStream inA = new PipedInputStream();
+        PipedOutputStream outA = new PipedOutputStream(inA);
+        PipedInputStream inB = new PipedInputStream();
+        PipedOutputStream outB = new PipedOutputStream(inB);
+        Endpoint iSender = new Endpoint(iBridge, inA, outB);
+        Endpoint iReceiver = new Endpoint(iBridge, inB, outA);
+
+        TestObject testObject = new TestObject();
+        String oId = (String)iBridge.mapInterfaceTo(testObject, new Type(XInterface.class));
+
+        testCall(iSender, iReceiver, oId);
+        testCallWithInParameter(iSender, iReceiver, oId);
+        testCallWithOutParameter(iSender, iReceiver, oId);
+        testCallWithInOutParameter(iSender, iReceiver, oId);
+        testCallWithResult(iSender, iReceiver, oId);
+        testCallWhichRaisesException(iSender, iReceiver, oId);
+        testCallWithIn_Out_InOut_Paramters_and_result(iSender, iReceiver, oId);
+        testCallWhichReturnsAny(iSender, iReceiver, oId);
+    }
+
+    public void testCall(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "method", new ThreadId(new byte[] { 0, 1 }), new Object[0]);
+        iReceiver.readMessage();
+
+        // send a reply
+        iReceiver.writeReply(false, new ThreadId(new byte[] { 0, 1 }), null);
+        iSender.readMessage();
+    }
+
+    public void testCallWithInParameter(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "methodWithInParameter", new ThreadId(new byte[] { 0, 1 }),
+            new Object[] { "hallo" });
+        Message iMessage = iReceiver.readMessage();
+        Object[] t_params = iMessage.getArguments();
+        assertEquals("hallo", t_params[0]);
+
+        // send a reply
+        iReceiver.writeReply(false, new ThreadId(new byte[] { 0, 1 }), null);
+        iMessage = iSender.readMessage();
+    }
+
+    public void testCallWithOutParameter(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        Object params[] = new Object[]{new String[1]};
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "methodWithOutParameter", new ThreadId(new byte[] { 0, 1 }),
+            params);
+        Message iMessage = iReceiver.readMessage();
+
+
+        Object[] t_params = iMessage.getArguments();
+        ((String [])t_params[0])[0] = "testString";
+
+        // send an exception as reply
+        iReceiver.writeReply(false, new ThreadId(new byte[] { 0, 1 }), null);
+        iSender.readMessage();
+
+        assertEquals("testString", ((String [])params[0])[0]);
+    }
+
+    public void testCallWithInOutParameter(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        Object params[] = new Object[]{new String[]{"inString"}};
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "methodWithInOutParameter", new ThreadId(new byte[] { 0, 1 }),
+            params);
+        Message iMessage = iReceiver.readMessage();
+
+
+        Object[] t_params = iMessage.getArguments();
+        assertEquals("inString", ((String [])t_params[0])[0]);
+
+        // provide reply
+        ((String [])t_params[0])[0] = "outString";
+
+        // send an exception as reply
+        iReceiver.writeReply(false, new ThreadId(new byte[] { 0, 1 }), null);
+        iSender.readMessage();
+
+        assertEquals("outString", ((String [])params[0])[0]);
+    }
+
+    public void testCallWithResult(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "methodWithResult", new ThreadId(new byte[] { 0, 1 }),
+            new Object[0]);
+        iReceiver.readMessage();
+
+        // send a reply
+        iReceiver.writeReply(
+            false, new ThreadId(new byte[] { 0, 1 }), "resultString");
+        Message iMessage = iSender.readMessage();
+        Object result = iMessage.getResult();
+
+        assertEquals("resultString", result);
+    }
+
+    public void testCallWhichRaisesException(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        // send a second request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "method", new ThreadId(new byte[] { 0, 1 }), new Object[0]);
+        iReceiver.readMessage();
+
+        // send an exception as reply
+        iReceiver.writeReply(
+            true, new ThreadId(new byte[] { 0, 1 }),
+            new com.sun.star.uno.RuntimeException("test the exception"));
+        Message iMessage = iSender.readMessage();
+
+        Object result = iMessage.getResult();
+
+        assertTrue(result instanceof com.sun.star.uno.RuntimeException);
+    }
+
+    public void testCallWithIn_Out_InOut_Paramters_and_result(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        Object params[] = new Object[]{"hallo", new String[1], new String[]{"inOutString"}};
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "MethodWithIn_Out_InOut_Paramters_and_result",
+            new ThreadId(new byte[] { 0, 1 }), params);
+        Message iMessage = iReceiver.readMessage();
+
+        Object[] t_params = iMessage.getArguments();
+
+        assertEquals("hallo", t_params[0]);
+
+        assertEquals("inOutString", ((String [])t_params[2])[0]);
+
+        ((String [])t_params[1])[0] = "outString";
+        ((String [])t_params[2])[0] = "inOutString_res";
+
+        // send an exception as reply
+        iReceiver.writeReply(
+            false, new ThreadId(new byte[] { 0, 1 }), "resultString");
+        iMessage = iSender.readMessage();
+
+        Object result = iMessage.getResult();
+        assertEquals("outString", ((String [])params[1])[0]);
+
+        assertEquals("inOutString_res", ((String [])params[2])[0]);
+
+        assertEquals("resultString", result);
+    }
+
+    public void testCallWhichReturnsAny(
+        Endpoint iSender, Endpoint iReceiver, String oId) throws Exception
+    {
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "returnAny", new ThreadId(new byte[] { 0, 1 }), null);
+        iReceiver.readMessage();
+        // send a reply
+        iReceiver.writeReply(
+            false, new ThreadId(new byte[] { 0, 1 }), Any.VOID);
+        Message iMessage = iSender.readMessage();
+        Object result = iMessage.getResult();
+        assertTrue(
+            result instanceof Any &&
+            ((TypeDescription.getTypeDescription(((Any) result).getType()).
+              getZClass()) ==
+             void.class));
+
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "returnAny", new ThreadId(new byte[] { 0, 1 }), null);
+        iReceiver.readMessage();
+        // send a reply
+        iReceiver.writeReply(
+            false, new ThreadId(new byte[] { 0, 1 }),
+            new Any(XInterface.class, null));
+        iMessage = iSender.readMessage();
+        result = iMessage.getResult();
+        assertNull(result);
+
+        // send an ordinary request
+        iSender.writeRequest(
+            oId, TypeDescription.getTypeDescription(TestXInterface.class),
+            "returnAny", new ThreadId(new byte[] { 0, 1 }), null);
+        iReceiver.readMessage();
+        // send a reply
+        iReceiver.writeReply(
+            false, new ThreadId(new byte[] { 0, 1 }), Integer.valueOf(501));
+        iMessage = iSender.readMessage();
+        result = iMessage.getResult();
+        assertEquals(501, result);
+    }
+
+    private static final class Endpoint {
+        public Endpoint(IBridge bridge, InputStream input, OutputStream output)
+            throws IOException
+        {
+            protocol = new urp(bridge, null, input, output);
+            new Thread() {
+                @Override
+                public void run() {
+                    for (;;) {
+                        Object o;
+                        try {
+                            o = protocol.readMessage();
+                        } catch (IOException e) {
+                            o = e;
+                        }
+                        synchronized (queue) {
+                            queue.addLast(o);
+                        }
+                    }
+                }
+            }.start();
+            protocol.init();
+        }
+
+        public Message readMessage() throws IOException {
+            for (;;) {
+                synchronized (queue) {
+                    if (!queue.isEmpty()) {
+                        Object o = queue.removeFirst();
+                        if (o instanceof Message) {
+                            return (Message) o;
+                        } else {
+                            throw (IOException) o;
+                        }
+                    }
+                }
+            }
+        }
+
+        public boolean writeRequest(
+            String oid, TypeDescription type, String function, ThreadId tid,
+            Object[] arguments)
+            throws IOException
+        {
+            return protocol.writeRequest(oid, type, function, tid, arguments);
+        }
+
+        public void writeReply(boolean exception, ThreadId tid, Object result)
+            throws IOException
+        {
+            protocol.writeReply(exception, tid, result);
+        }
+
+        private final IProtocol protocol;
+        private final LinkedList<Object> queue = new LinkedList<Object>();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestBridge.java b/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestBridge.java
new file mode 100644
index 000000000..acd1b3948
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestBridge.java
@@ -0,0 +1,106 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.protocols.urp;
+
+import java.io.IOException;
+
+import java.util.HashMap;
+
+
+import com.sun.star.uno.IBridge;
+import com.sun.star.uno.IEnvironment;
+import com.sun.star.uno.Type;
+
+
+class TestBridge implements IBridge {
+    private static final boolean DEBUG = false;
+
+    private final HashMap<String,Object> _hashtable = new HashMap<String,Object>();
+
+    private IEnvironment _source ;//= new com.sun.star.lib.uno.environments.java.java_environment(null);
+
+
+    private class MyEnv implements IEnvironment {
+        public Object getContext() {
+            return null;
+        }
+
+        public String getName() {
+            return null;
+        }
+
+        public Object registerInterface(Object object, String oId[], Type type) {
+            return null;
+        }
+
+        public void revokeInterface(String oId, Type type) {
+        }
+
+        public Object getRegisteredInterface(String oid, Type type) {
+            Object object = _hashtable.get(oid);
+
+            if(DEBUG) System.err.println("##### " + getClass().getName() + ".getRegisteredInterface:" + oid + " " + object);
+
+            return object;
+        }
+
+        public String getRegisteredObjectIdentifier(Object object) {
+            return null;
+        }
+
+        public void list() {
+        }
+    }
+
+    TestBridge() {
+        _source = new MyEnv();
+    }
+
+    public Object mapInterfaceTo(Object object, Type type) {
+        if (object == null) {
+            return null;
+        } else {
+            String oid = ">" + object.toString() + type.toString() + "<";
+            _hashtable.put(oid, object);
+            return oid;
+        }
+    }
+
+    public Object mapInterfaceFrom(Object object, Type type) {
+        String oid = (String)object;
+
+        return _hashtable.get(oid);
+    }
+
+    public IEnvironment getSourceEnvironment() {
+        return _source;
+    }
+
+    public IEnvironment getTargetEnvironment() {
+        return null;
+    }
+
+    public void acquire() {}
+
+    public void release() {}
+
+    public void dispose() throws InterruptedException, IOException {}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestObject.java b/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestObject.java
new file mode 100644
index 000000000..f36710e1d
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/TestObject.java
@@ -0,0 +1,63 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.uno.protocols.urp;
+
+
+
+class TestObject implements TestXInterface {
+    public void method1( /*IN*/java.lang.Object itf ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public void method2( /*OUT*/java.lang.Object[] itf ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public void method3( /*INOUT*/java.lang.Object[] itf ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public Object method4(  ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+        return null;
+    }
+
+    public Object returnAny(  ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+        return null;
+    }
+
+
+    public void method() throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public void methodWithInParameter( /*IN*/String text ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public void methodWithOutParameter( /*OUT*/String[] text ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public void methodWithInOutParameter( /*INOUT*/String[] text ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+    }
+
+    public String methodWithResult(  ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+        return "TestObject_resultString";
+    }
+
+    public String MethodWithIn_Out_InOut_Paramters_and_result( /*IN*/String text, /*OUT*/String[] outtext, /*INOUT*/String[] inouttext ) throws com.sun.star.uno.Exception, com.sun.star.uno.RuntimeException {
+        return "TestObject_resultString";
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/protocols/urp/interfaces.idl b/ridljar/test/com/sun/star/lib/uno/protocols/urp/interfaces.idl
new file mode 100644
index 000000000..4ea1c8ebc
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/protocols/urp/interfaces.idl
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 .
+ */
+
+#include <com/sun/star/uno/XInterface.idl>
+#include <com/sun/star/beans/XPropertySet.idl>
+#include <com/sun/star/uno/Exception.idl>
+#include <com/sun/star/uno/Any.idl>
+
+module com { module sun { module star { module lib { module uno {
+module protocols { module urp {
+
+    struct TestPrimitiveStruct {
+        boolean        zBool;
+        short          zShort;
+        unsigned short zUShort;
+        long           zLong;
+        unsigned long  zULong;
+        hyper          zHyper;
+        unsigned hyper zUHyper;
+        float          zFloat;
+        double         zDouble;
+        char           zChar;
+        byte           zByte;
+        string         zString;
+        any            zAny;
+    };
+
+    struct TestPrimitiveSeqStruct {
+        sequence<boolean>        zBool;
+        sequence<short>          zShort;
+        sequence<unsigned short> zUShort;
+        sequence<long>           zLong;
+        sequence<unsigned long>  zULong;
+        sequence<hyper>          zHyper;
+        sequence<unsigned hyper> zUHyper;
+        sequence<float>          zFloat;
+        sequence<double>         zDouble;
+        sequence<char>           zChar;
+        sequence<byte>           zByte;
+        sequence<string>         zString;
+        sequence<any>            zAny;
+    };
+
+    struct TestNestedStruct {
+        TestPrimitiveStruct    primitiveStruct;
+        TestPrimitiveSeqStruct primitiveSeqStruct;
+    };
+
+    struct TestNestedSeqStruct {
+        sequence< sequence< long > > val;
+    };
+
+    interface TestXInterface : com::sun::star::uno::XInterface {
+        void method1([in] com::sun::star::uno::XInterface itf) raises( com::sun::star::uno::Exception );
+        void method2([out] com::sun::star::uno::XInterface itf) raises( com::sun::star::uno::Exception );
+        void method3([inout] com::sun::star::uno::XInterface itf) raises( com::sun::star::uno::Exception );
+        com::sun::star::uno::XInterface method4() raises( com::sun::star::uno::Exception );
+
+        any returnAny() raises( com::sun::star::uno::Exception );
+
+        void  method() raises( com::sun::star::uno::Exception );
+        void  methodWithInParameter([in] string text) raises( com::sun::star::uno::Exception );
+        void  methodWithOutParameter([out] string text) raises( com::sun::star::uno::Exception );
+        void  methodWithInOutParameter([inout] string text) raises( com::sun::star::uno::Exception );
+        string  methodWithResult() raises( com::sun::star::uno::Exception );
+
+        string MethodWithIn_Out_InOut_Paramters_and_result([in] string text, [out] string outtext, [inout] string inouttext) raises( com::sun::star::uno::Exception );
+    };
+
+    struct TestInterfaceStruct
+    {
+        com::sun::star::uno::XInterface hallo;
+
+        com::sun::star::beans::XPropertySet hallo2;
+    };
+
+    enum TestEnum {
+        A = 7,
+        B = 8,
+        C = 11
+    };
+
+}; }; }; }; }; }; };
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/uno/typedesc/TypeDescription_Test.java b/ridljar/test/com/sun/star/lib/uno/typedesc/TypeDescription_Test.java
new file mode 100644
index 000000000..13271dc0e
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/uno/typedesc/TypeDescription_Test.java
@@ -0,0 +1,298 @@
+/*
+ * 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 com.sun.star.lib.uno.typedesc;
+
+import com.sun.star.lib.uno.typeinfo.MethodTypeInfo;
+import com.sun.star.lib.uno.typeinfo.TypeInfo;
+import com.sun.star.uno.Any;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.TypeClass;
+import com.sun.star.uno.XInterface;
+import com.sun.star.uno.XNamingService;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class TypeDescription_Test {
+    @Test public void test() throws Exception {
+        TypeDescription voidTD = TypeDescription.getTypeDescription(
+            void.class);
+        TypeDescription stringTD = TypeDescription.getTypeDescription(
+            String.class);
+        TypeDescription typeTD = TypeDescription.getTypeDescription(
+            Type.class);
+        TypeDescription anyTD = TypeDescription.getTypeDescription(Any.class);
+        TypeDescription interfaceTD = TypeDescription.getTypeDescription(
+            XInterface.class);
+
+        MethodSignature sigBuildinSyncTypeToAny = new MethodSignature(
+            true, false, new TypeDescription[] { typeTD },
+            new TypeDescription[1], anyTD);
+        MethodSignature sigBuildinAsyncToVoid = new MethodSignature(
+            true, true, new TypeDescription[0], new TypeDescription[0],
+            voidTD);
+        MethodSignature sigAddonSyncStringToVoid = new MethodSignature(
+            false, false, new TypeDescription[] { stringTD },
+            new TypeDescription[1], voidTD);
+        MethodSignature sigAddonSyncStringInterfaceToVoid = new MethodSignature(
+            false, false, new TypeDescription[] { stringTD, interfaceTD },
+            new TypeDescription[2], voidTD);
+        MethodSignature sigAddonSyncStringToInterface = new MethodSignature(
+            false, false, new TypeDescription[] { stringTD },
+            new TypeDescription[1], interfaceTD);
+
+        TypeSignature emptyTypeSig = new TypeSignature(
+            null, new String[0], null, new String[0], null);
+        TypeSignature interfaceTypeSig = new TypeSignature(
+            null, new String[] { "queryInterface", "acquire", "release" },
+            new MethodSignature[] { sigBuildinSyncTypeToAny,
+                                    sigBuildinAsyncToVoid,
+                                    sigBuildinAsyncToVoid },
+            new String[0], null);
+        TypeSignature exceptionTypeSig = new TypeSignature(
+            null, new String[0], null,
+            new String[]{"Context"}, new TypeSignature[] { interfaceTypeSig });
+            // com.sun.star.uno.Exception.idl says that Exception (a) has no
+            // base exception, and (b) has two fields, Message and Context; the
+            // generated com.sun.star.uno.Exception.java, however, (a) is
+            // inherited from java.lang.Exception, and (b) has only one field,
+            // Context, as Message is inherited from java.lang.Exception
+        TypeSignature namingServiceTypeSig = new TypeSignature(
+            interfaceTypeSig,
+            new String[] { "getRegisteredObject", "registerObject",
+                           "revokeObject" },
+            new MethodSignature[] { sigAddonSyncStringToInterface,
+                                    sigAddonSyncStringInterfaceToVoid,
+                                    sigAddonSyncStringToVoid },
+            new String[0], null);
+
+        Object[] byteData = new Object[] {
+            "byte", "[B", byte.class, TypeClass.BYTE };
+        Object[] stringData = new Object[] {
+            "string", "[Ljava.lang.String;", java.lang.String.class,
+            TypeClass.STRING };
+        Object[] typeClassData = new Object[] {
+            "com.sun.star.uno.TypeClass", "[Lcom.sun.star.uno.TypeClass;",
+            TypeClass.class, TypeClass.ENUM };
+        Object[] interfaceData = new Object[] {
+            "com.sun.star.uno.XInterface", "[Lcom.sun.star.uno.XInterface;",
+            XInterface.class, TypeClass.INTERFACE };
+        Object[] exceptionData = new Object [] {
+            "com.sun.star.uno.Exception", "[Lcom.sun.star.uno.Exception;",
+            com.sun.star.uno.Exception.class, TypeClass.EXCEPTION,
+            new Object[] { interfaceData } };
+        Object[] namingServiceData = new Object[] {
+            "com.sun.star.uno.XNamingService",
+            "[Lcom.sun.star.uno.XNamingService;", XNamingService.class,
+            TypeClass.INTERFACE, null, interfaceData };
+
+        emptyTypeSig.test("TypeSignature.test(byte)", byteData,
+                          TypeDescription.getTypeDescription("byte"));
+        emptyTypeSig.test("TypeSignature.test(string)", stringData,
+                          TypeDescription.getTypeDescription("string"));
+        emptyTypeSig.test("TypeSignature.test(TypeClass)", typeClassData,
+                          TypeDescription.getTypeDescription(
+                              "com.sun.star.uno.TypeClass"));
+        exceptionTypeSig.test("TypeSignature.test(com.sun.star.uno.Exception)",
+                              exceptionData,
+                              TypeDescription.getTypeDescription(
+                                  "com.sun.star.uno.Exception"));
+        interfaceTypeSig.test("TypeSignature.test(XInterface)", interfaceData,
+                              TypeDescription.getTypeDescription(
+                                  "com.sun.star.uno.XInterface"));
+        namingServiceTypeSig.test("TypeSignature.test(XNamingService)",
+                                  namingServiceData,
+                                  TypeDescription.getTypeDescription(
+                                      "com.sun.star.uno.XNamingService"));
+    }
+
+    @Test public void testUnsigned() throws ClassNotFoundException {
+        assertEquals(
+            "TypeDescription for UNSIGNED LONG", "unsigned long",
+            TypeDescription.getTypeDescription(Type.UNSIGNED_LONG).getTypeName());
+    }
+
+    @Test public void testGetMethodDescription() {
+        TypeDescription td = TypeDescription.getTypeDescription(XDerived.class);
+        td.getMethodDescription("fn");
+    }
+
+    @Test public void testSequence() throws ClassNotFoundException {
+        assertEquals(
+            "unsigned short",
+            TypeDescription.getTypeDescription("[]unsigned short").getComponentType().getTypeName());
+    }
+
+    public interface XBase extends XInterface {
+        void fn();
+
+        TypeInfo[] UNOTYPEINFO = { new MethodTypeInfo("fn", 0, 0) };
+    }
+
+    public interface XDerived extends XBase {
+        TypeInfo[] UNOTYPEINFO = null;
+    }
+
+    private final class MethodSignature {
+        public MethodSignature(
+            boolean buildIn, boolean oneWay, TypeDescription[] inParameters,
+            TypeDescription[] outParameters, TypeDescription returnValue)
+        {
+            this.buildIn = buildIn;
+            this.oneWay = oneWay;
+            this.inParameters = inParameters;
+            this.outParameters = outParameters;
+            this.returnValue = returnValue;
+        }
+
+        public void test(String prefix, int index,
+                         MethodDescription description) {
+            assertEquals(prefix + "; getIndex", index, description.getIndex());
+            assertEquals(
+                prefix + "; getMethod", buildIn,
+                description.getMethod() == null);
+            assertEquals(prefix + "; isOneway", oneWay, description.isOneway());
+            TypeDescription[] in = description.getInSignature();
+            assertEquals(
+                prefix + "; getInSignature", inParameters.length, in.length);
+            for (int i = 0; i < in.length; ++i) {
+                assertEquals(
+                    prefix + "; getInSignature " + i, inParameters[i], in[i]);
+            }
+            TypeDescription[] out = description.getOutSignature();
+            assertEquals(
+                prefix + "; getOutSignature", outParameters.length, out.length);
+            for (int i = 0; i < out.length; ++i) {
+                assertTrue(
+                    prefix + "; getOutSignature " + i,
+                    (out[i] == null
+                     ? outParameters[i] == null
+                     : out[i].equals(outParameters[i])));
+            }
+            assertEquals(
+                prefix + "; getReturnSignature", returnValue,
+                description.getReturnSignature());
+        }
+
+        private final boolean buildIn;
+        private final boolean oneWay;
+        private final TypeDescription[] inParameters;
+        private final TypeDescription[] outParameters;
+        private final TypeDescription returnValue;
+    }
+
+    private final class TypeSignature {
+        public TypeSignature(TypeSignature superType, String[] methodNames,
+                             MethodSignature[] methodSignatures,
+                             String[] fieldNames,
+                             TypeSignature[] fieldSignatures) {
+            this._superType = superType;
+            this.methodNames = methodNames;
+            this.methodSignatures = methodSignatures;
+            methodOffset = superType == null ? 0
+                : superType.methodOffset + superType.methodNames.length;
+            this.fieldSignatures = fieldSignatures;
+            this.fieldNames = fieldNames;
+            fieldOffset = superType == null ? 0
+                : superType.fieldOffset + superType.fieldNames.length;
+        }
+
+        public void test(String prefix, Object[] data,
+                         TypeDescription description) throws Exception {
+            assertEquals(
+                prefix + "; getTypeName", data[0], description.getTypeName());
+            assertEquals(
+                prefix + "; equals",
+                TypeDescription.getTypeDescription((String)data[0]),
+                description);
+            assertEquals(
+                prefix + "; getArrayTypeName", data[1],
+                description.getArrayTypeName());
+            assertSame(
+                prefix + "; getZClass", data[2], description.getZClass());
+            assertSame(
+                prefix + "; getTypeClass", data[3], description.getTypeClass());
+            assertNull(
+                prefix + "; getComponentType", description.getComponentType());
+
+            MethodDescription[] mds = description.getMethodDescriptions();
+            assertTrue(
+                prefix + "; getMethodDescriptions",
+                mds == null
+                    ? methodSignatures == null
+                    : mds.length == methodSignatures.length);
+            if (methodSignatures != null) {
+                for (int i = 0; i < methodSignatures.length; ++i) {
+                    methodSignatures[i].test(
+                        prefix + "; getMethodDescriptions " + i,
+                        i + methodOffset, mds[i]);
+                }
+            }
+            for (int i = 0; i < methodNames.length; ++i) {
+                MethodDescription md = description.getMethodDescription(
+                    i + methodOffset);
+                assertNotNull(
+                    prefix + "; getMethodDescription " + (i + methodOffset),
+                    md);
+                methodSignatures[i].test(
+                    prefix + "; getMethodDescription " + (i + methodOffset),
+                    i + methodOffset, md);
+            }
+            for (int i = 0; i < methodNames.length; ++i) {
+                MethodDescription md = description.getMethodDescription(
+                    methodNames[i]);
+                assertNotNull(
+                    prefix + "; getMethodDescription " + methodNames[i], md);
+                methodSignatures[i].test(
+                    prefix + "; getMethodDescription " + methodNames[i],
+                    i + methodOffset, md);
+            }
+
+            FieldDescription[] fds = description.getFieldDescriptions();
+            assertTrue(
+                prefix + "; getFieldDescriptions",
+                fds == null
+                    ? fieldSignatures == null
+                    : fds.length == fieldSignatures.length);
+            if (fieldSignatures != null) {
+                for (int i = 0; i < fieldSignatures.length; ++i) {
+                    fieldSignatures[i].test(
+                        prefix + "; getFieldDescriptions " + i,
+                        (Object[]) ((Object[]) data[4])[i],
+                        fds[i].getTypeDescription());
+                }
+            }
+
+            TypeDescription supert = description.getSuperType();
+            assertEquals(
+                prefix + "; getSuperType", data.length < 6, supert == null);
+            if (supert != null && data[5] != null) {
+                _superType.test(prefix + "; getSuperType", (Object[]) data[5],
+                                supert);
+            }
+        }
+
+        private final TypeSignature _superType;
+        private final MethodSignature[] methodSignatures;
+        private final String[] methodNames;
+        private final int methodOffset;
+        private final TypeSignature[] fieldSignatures;
+        private final String[] fieldNames;
+        private final int fieldOffset;
+    }
+}
diff --git a/ridljar/test/com/sun/star/lib/util/NativeLibraryLoader_Test.java b/ridljar/test/com/sun/star/lib/util/NativeLibraryLoader_Test.java
new file mode 100644
index 000000000..e4101f2dd
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/util/NativeLibraryLoader_Test.java
@@ -0,0 +1,76 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.lib.util;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class NativeLibraryLoader_Test {
+    @Test public void testEncoded() throws MalformedURLException {
+        File dir = new File(System.getProperty("user.dir"));
+        File subdir = new File(dir, "with space");
+        File file1 = new File(subdir, "file");
+
+        String fileUrl = dir.toURI().toURL().toString();
+        if (!fileUrl.endsWith("/")) {
+            fileUrl += "/";
+        }
+        fileUrl += "with%20space/file";
+        final URL url = new URL(fileUrl);
+
+        File file2 = NativeLibraryLoader.getResource(
+            new ClassLoader() {
+                @Override
+                public URL getResource(String name) {
+                    return url;
+                }
+            },
+            "dummy");
+        assertEquals("Files are equal", file1, file2);
+    }
+
+    @Test public void testUnencoded() throws MalformedURLException {
+        File dir = new File(System.getProperty("user.dir"));
+        File subdir = new File(dir, "with space");
+        File file1 = new File(subdir, "file");
+
+        String fileUrl = dir.toURI().toURL().toString();
+        if (!fileUrl.endsWith("/")) {
+            fileUrl += "/";
+        }
+        fileUrl += "with space/file";
+        final URL url = new URL(fileUrl);
+
+        File file2 = NativeLibraryLoader.getResource(
+            new ClassLoader() {
+                @Override
+                public URL getResource(String name) {
+                    return url;
+                }
+            },
+            "dummy");
+        assertEquals("Files are equal", file1, file2);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/lib/util/WeakMap_Test.java b/ridljar/test/com/sun/star/lib/util/WeakMap_Test.java
new file mode 100644
index 000000000..378a1ac78
--- /dev/null
+++ b/ridljar/test/com/sun/star/lib/util/WeakMap_Test.java
@@ -0,0 +1,74 @@
+/*
+ * 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 com.sun.star.lib.util;
+
+import org.junit.Test;
+import util.WaitUnreachable;
+import static org.junit.Assert.*;
+
+public final class WeakMap_Test {
+    @Test public void test() {
+        WeakMap<String,Object> m = new WeakMap<String,Object>();
+        assertEquals(0, m.size());
+        assertTrue(m.isEmpty());
+        assertFalse(m.containsKey("key1"));
+        assertFalse(m.containsValue(null));
+        WaitUnreachable u1 = new WaitUnreachable(new Object());
+        m.put("key1", u1.get());
+        WaitUnreachable u2 = new WaitUnreachable(new Disposable());
+        m.put("key2", u2.get());
+        assertEquals(2, m.size());
+        assertFalse(m.isEmpty());
+        assertTrue(m.containsKey("key1"));
+        assertTrue(m.containsKey("key2"));
+        assertFalse(m.containsKey("key3"));
+        assertTrue(m.containsValue(m.get("key1")));
+        assertTrue(m.containsValue(m.get("key2")));
+        assertEquals(u1.get(), WeakMap.getValue(m.get("key1")));
+        assertEquals(u2.get(), WeakMap.getValue(m.get("key2")));
+        assertEquals(2, m.values().size());
+        assertTrue(m.values().contains(m.get("key1")));
+        assertTrue(m.values().contains(m.get("key2")));
+        u1.waitUnreachable();
+        assertNull(WeakMap.getValue(m.get("key1")));
+        ((Disposable) u2.get()).dispose();
+        assertNull(WeakMap.getValue(m.get("key2")));
+        m.clear();
+        u2.waitUnreachable();
+        assertEquals(0, m.size());
+        m.put("key2", new Object());
+        assertEquals(1, m.size());
+    }
+
+    // This simple class (single listener, no synchronization) exploits
+    // knowledge about the implementation of WeakMap:
+    private static final class Disposable implements DisposeNotifier {
+        public void addDisposeListener(DisposeListener listener) {
+            this.listener = listener;
+        }
+
+        public void dispose() {
+            if (listener != null) {
+                listener.notifyDispose(this);
+            }
+        }
+
+        private DisposeListener listener = null;
+    }
+}
diff --git a/ridljar/test/com/sun/star/uno/AnyConverter_Test.java b/ridljar/test/com/sun/star/uno/AnyConverter_Test.java
new file mode 100644
index 000000000..faa955a96
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/AnyConverter_Test.java
@@ -0,0 +1,904 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.uno;
+
+import com.sun.star.lang.XTypeProvider;
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+
+public final class AnyConverter_Test {
+    Any anyBool;
+    Any anyChar;
+    Any anyByte;
+    Any anyShort;
+    Any anyInt;
+    Any anyLong;
+    Any anyFloat;
+    Any anyDouble;
+    Any anyStr;
+    Any anyType;
+    Any anyArByte;
+    Any anyVoid;
+    Any anyXTypeProvider;
+
+    Boolean aBool;
+    Character aChar;
+    Byte aByte;
+    Short aShort;
+    Integer aInt;
+    Long aLong;
+    Float aFloat;
+    Double aDouble;
+    Object aObj;
+    String aStr;
+    Type aType;
+    byte[] arByte;
+
+    /** Class variables are initialized before each Test method */
+    @Before public void setUp()
+    {
+        aBool= Boolean.TRUE;
+        aChar= new Character('A');
+        aByte= Byte.valueOf((byte) 111);
+        aShort= Short.valueOf((short) 11111);
+        aInt= Integer.valueOf( 1111111);
+        aLong= Long.valueOf( 0xffffffff);
+        aFloat= new Float( 3.14);
+        aDouble= new Double( 3.145);
+        aObj= new ATypeProvider();
+        aStr= "I am a string";
+        aType= new Type(String.class);
+        arByte= new byte[] {1,2,3};
+
+        anyVoid= new Any(new Type(void.class), null);
+        anyBool= new Any(new Type(Boolean.TYPE), aBool);
+        anyChar= new Any(new Type(Character.TYPE), aChar);
+        anyByte= new Any(new Type(Byte.TYPE), aByte);
+        anyShort= new Any(new Type(Short.TYPE), aShort);
+        anyInt= new Any(new Type(Integer.TYPE), aInt);
+        anyLong= new Any(new Type(Long.TYPE), aLong);
+        anyFloat= new Any(new Type(Float.TYPE), aFloat);
+        anyDouble= new Any(new Type(Double.TYPE), aDouble);
+        anyStr= new Any(new Type(String.class), aStr);
+        anyType= new Any(new Type(Type.class), aType);
+        anyArByte= new Any(new Type(byte[].class), arByte);
+        anyXTypeProvider= new Any(new Type(XTypeProvider.class), aObj);
+    }
+
+    @Test public void test_toBoolean()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        boolean b= AnyConverter.toBoolean(aBool);
+        assertEquals(b, aBool.booleanValue());
+        b= AnyConverter.toBoolean(anyBool);
+        assertEquals(b, ((Boolean)anyBool.getObject()).booleanValue());
+
+        // must fail
+        try { AnyConverter.toBoolean(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toBoolean(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toChar()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        char b= AnyConverter.toChar(aChar);
+        assertEquals(b, aChar.charValue());
+        b= AnyConverter.toChar(anyChar);
+        assertEquals(b, ((Character)anyChar.getObject()).charValue());
+
+        // must fail
+        try { AnyConverter.toChar(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toByte()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        byte val= AnyConverter.toByte(aByte);
+        assertEquals(val, aByte.byteValue());
+        val= AnyConverter.toByte(anyByte);
+        assertEquals(val, ((Byte)anyByte.getObject()).byteValue());
+
+        // must fail
+        try { AnyConverter.toByte(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toByte(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toShort()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        short sh= AnyConverter.toShort(aByte);
+        assertEquals(sh, aByte.byteValue());
+        sh= AnyConverter.toShort(aShort);
+        assertEquals(sh, aShort.shortValue());
+        sh= AnyConverter.toShort(anyByte);
+        assertEquals(sh, ((Byte)anyByte.getObject()).byteValue());
+        sh= AnyConverter.toShort(anyShort);
+        assertEquals(sh, ((Short) anyShort.getObject()).shortValue());
+        Any a = new Any( Type.UNSIGNED_SHORT, Short.valueOf((short)5) );
+        assertEquals(5, AnyConverter.toUnsignedShort( a ));
+
+        // must fail
+        try { AnyConverter.toShort(a); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toUnsignedShort(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toChar(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toShort(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toInt()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        int val= AnyConverter.toInt(aByte);
+        assertEquals(val, aByte.byteValue());
+        val= AnyConverter.toInt(aShort);
+        assertEquals(val, aShort.shortValue());
+        val= AnyConverter.toInt(aInt);
+        assertEquals(val, aInt.intValue());
+        val= AnyConverter.toInt(anyByte);
+        assertEquals(val, ((Byte)anyByte.getObject()).byteValue());
+        val= AnyConverter.toInt(anyShort);
+        assertEquals(val, ((Short) anyShort.getObject()).shortValue());
+        val= AnyConverter.toInt(anyInt);
+        assertEquals(val, ((Integer) anyInt.getObject()).intValue());
+        Any a = new Any( Type.UNSIGNED_SHORT, Short.valueOf((short)5) );
+        assertEquals(5, AnyConverter.toInt(a));
+        assertEquals(5, AnyConverter.toUnsignedInt(a));
+        a = new Any( Type.UNSIGNED_LONG, Integer.valueOf(5) );
+        assertEquals(5, AnyConverter.toUnsignedInt(a));
+
+        // must fail
+        try { AnyConverter.toUnsignedInt(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(a); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toUnsignedInt(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toInt(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toLong()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        long val= AnyConverter.toLong(aByte);
+        assertEquals(val, aByte.byteValue());
+        val= AnyConverter.toLong(aShort);
+        assertEquals(val, aShort.shortValue());
+        val= AnyConverter.toLong(aInt);
+        assertEquals(val, aInt.intValue());
+        val= AnyConverter.toLong(aLong);
+        assertEquals(val, aLong.longValue());
+        val= AnyConverter.toLong(anyByte);
+        assertEquals(val, ((Byte)anyByte.getObject()).byteValue());
+        val= AnyConverter.toLong(anyShort);
+        assertEquals(val, ((Short) anyShort.getObject()).shortValue());
+        val= AnyConverter.toLong(anyInt);
+        assertEquals(val, ((Integer) anyInt.getObject()).intValue());
+        val= AnyConverter.toLong(anyLong);
+        assertEquals(val, ((Long) anyLong.getObject()).longValue());
+        Any a = new Any( Type.UNSIGNED_SHORT, Short.valueOf((short)5) );
+        assertEquals(5, AnyConverter.toLong(a));
+        assertEquals(5, AnyConverter.toUnsignedLong(a));
+        a = new Any( Type.UNSIGNED_LONG, Integer.valueOf(5) );
+        assertEquals(5, AnyConverter.toUnsignedLong(a));
+        assertEquals(5, AnyConverter.toLong(a));
+        a = new Any( Type.UNSIGNED_HYPER, Long.valueOf(5) );
+        assertEquals(5, AnyConverter.toUnsignedLong(a));
+
+        // must fail
+        try { AnyConverter.toUnsignedLong(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toUnsignedLong(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(a); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toUnsignedLong(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toLong(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toFloat()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        float val= AnyConverter.toFloat(aByte);
+        assertEquals(val, aByte.byteValue(), 0); // 111 = 111.0
+        val= AnyConverter.toFloat(anyByte);
+        assertEquals(val, ((Byte)anyByte.getObject()).byteValue(), 0);
+        val= AnyConverter.toFloat(aShort);
+        assertEquals(val, aShort.shortValue(), 0); //11111 = 11111.0
+        val= AnyConverter.toFloat(anyShort);
+        assertEquals(val, ((Short) anyShort.getObject()).shortValue(), 0);
+        val= AnyConverter.toFloat(aFloat);
+        assertEquals(val, aFloat.floatValue(), 0);
+        val= AnyConverter.toFloat(anyFloat);
+        assertEquals(val, ((Float) anyFloat.getObject()).floatValue(), 0);
+
+        // must fail
+        try { AnyConverter.toFloat(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toFloat(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toDouble()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        double val= AnyConverter.toDouble(aByte);
+        assertEquals(val, aByte.byteValue(), 0); // 111 = 111.0
+        val= AnyConverter.toDouble(anyByte);
+        assertEquals(val, ((Byte)anyByte.getObject()).byteValue(), 0);
+        val= AnyConverter.toDouble(aShort);
+        assertEquals(val, aShort.shortValue(), 0); //11111 = 11111.0
+        val= AnyConverter.toDouble(anyShort);
+        assertEquals(val, ((Short) anyShort.getObject()).shortValue(), 0);
+        val= AnyConverter.toDouble(aInt);
+        assertEquals(val, aInt.intValue(), 0);
+        val= AnyConverter.toDouble(anyInt);
+        assertEquals(val, ((Integer) anyInt.getObject()).intValue(), 0);
+        val= AnyConverter.toDouble(aFloat);
+        assertEquals(val, aFloat.floatValue(), 0);
+        val= AnyConverter.toDouble(anyFloat);
+        float float1= ((Float) anyFloat.getObject()).floatValue();
+        assertTrue(val <= (float1 + 0.1) || val >= (float1 - 0.1));
+        val= AnyConverter.toDouble(aDouble);
+        assertEquals(val, aDouble.doubleValue(), 0);
+        val= AnyConverter.toDouble(anyDouble);
+        assertEquals(val, ((Double) anyDouble.getObject()).doubleValue(), 0);
+
+        // must fail
+        try { AnyConverter.toDouble(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toDouble(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toObject()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        Type _type= new Type(XTypeProvider.class);
+        Object val= AnyConverter.toObject(_type, aObj);
+        assertTrue(UnoRuntime.areSame(val, aObj));
+        val= AnyConverter.toObject(
+            _type, new Any( new Type(XTypeProvider.class), null));
+        assertNull(val);
+
+        // structs, exceptions
+        com.sun.star.lang.IllegalArgumentException exc =
+            new com.sun.star.lang.IllegalArgumentException();
+        Any any_exc = new Any(
+            new Type("com.sun.star.lang.IllegalArgumentException",
+                     TypeClass.EXCEPTION), exc);
+        assertEquals(
+            exc,
+            AnyConverter.toObject(
+                new Type(com.sun.star.lang.IllegalArgumentException.class),
+                any_exc));
+        assertEquals(
+            exc,
+            AnyConverter.toObject(
+                new Type(com.sun.star.uno.RuntimeException.class), any_exc));
+        try {
+            AnyConverter.toObject(
+                new Type(com.sun.star.uno.Exception.class), any_exc);
+            fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        any_exc = new Any(com.sun.star.lang.IllegalArgumentException.class,
+                          exc);
+        assertEquals(
+            exc,
+            AnyConverter.toObject(
+                new Type(com.sun.star.lang.IllegalArgumentException.class),
+                any_exc));
+        assertEquals(
+            exc,
+            AnyConverter.toObject(
+                new Type(com.sun.star.uno.RuntimeException.class), any_exc));
+        try {
+            AnyConverter.toObject(
+                new Type(com.sun.star.uno.Exception.class), any_exc);
+            fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+
+        // must fail
+        try { AnyConverter.toObject(_type, aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toObject(_type, anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toObject(_type, anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toObject(_type, new Object()); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toString()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        String val= AnyConverter.toString(aStr);
+        assertEquals(val, aStr);
+        val= AnyConverter.toString(anyStr);
+        assertEquals(val, anyStr.getObject());
+
+        // must fail
+        try { AnyConverter.toString(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(aType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyType); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toString(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toType()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        Type val= AnyConverter.toType(aType);
+        assertSame(val, aType);
+        val= AnyConverter.toType(anyType);
+        assertSame(val, anyType.getObject());
+
+        // must fail
+        try { AnyConverter.toType(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_toArray()
+        throws com.sun.star.lang.IllegalArgumentException
+    {
+        // must work
+        Object val= AnyConverter.toArray(arByte);
+        assertSame(val, arByte);
+        val= AnyConverter.toArray(anyArByte);
+        assertSame(val, anyArByte.getObject());
+
+        // must fail
+        try { AnyConverter.toType(aBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyBool); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyChar); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyShort); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyInt); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyLong); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyFloat); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyDouble); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aObj); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(aStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyStr); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyVoid); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(arByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+        try { AnyConverter.toType(anyArByte); fail();
+        } catch (com.sun.star.lang.IllegalArgumentException ie) {}
+    }
+
+    @Test public void test_isBoolean() {
+        assertTrue(AnyConverter.isBoolean(aBool));
+        assertTrue(AnyConverter.isBoolean(anyBool));
+        assertFalse(AnyConverter.isBoolean(aChar));
+    }
+
+    @Test public void test_isChar() {
+        assertTrue(AnyConverter.isChar(aChar));
+        assertTrue(AnyConverter.isChar(anyChar));
+        assertFalse(AnyConverter.isChar(aBool));
+    }
+
+    @Test public void test_isByte() {
+        assertTrue(AnyConverter.isByte(aByte));
+        assertTrue(AnyConverter.isByte(anyByte));
+        assertFalse(AnyConverter.isByte(aBool));
+    }
+
+    @Test public void test_isShort() {
+        assertTrue(AnyConverter.isShort(aShort));
+        assertTrue(AnyConverter.isShort(anyShort));
+        assertEquals(Type.SHORT, AnyConverter.getType(anyShort));
+        Any a = new Any( Type.UNSIGNED_SHORT, Short.valueOf((short)5) );
+        assertEquals(Type.UNSIGNED_SHORT, AnyConverter.getType(a));
+        assertFalse(AnyConverter.isShort(a));
+        assertFalse(Type.SHORT.equals(AnyConverter.getType(a)));
+        assertFalse(AnyConverter.isShort(aBool));
+    }
+
+    @Test public void test_isInt() {
+        assertTrue(AnyConverter.isInt(aInt));
+        assertTrue(AnyConverter.isInt(anyInt));
+        assertEquals(Type.LONG, AnyConverter.getType(anyInt));
+        Any a = new Any(Type.UNSIGNED_LONG, Integer.valueOf(5));
+        assertEquals(Type.UNSIGNED_LONG, AnyConverter.getType(a));
+        assertFalse(AnyConverter.isInt(a));
+        assertFalse(Type.LONG.equals(AnyConverter.getType(a)));
+        assertFalse(AnyConverter.isInt(aBool));
+    }
+
+    @Test public void test_isLong() {
+        assertTrue(AnyConverter.isLong(aLong));
+        assertTrue(AnyConverter.isLong(anyLong));
+        assertEquals(Type.HYPER, AnyConverter.getType(anyLong));
+        Any a = new Any( Type.UNSIGNED_HYPER, Long.valueOf(5) );
+        assertEquals(Type.UNSIGNED_HYPER, AnyConverter.getType(a));
+        assertFalse(AnyConverter.isLong(a));
+        assertFalse(Type.HYPER.equals( AnyConverter.getType(a) ));
+        assertFalse(AnyConverter.isLong(aBool));
+    }
+
+    @Test public void test_isFloat() {
+        assertTrue(AnyConverter.isFloat(aFloat));
+        assertTrue(AnyConverter.isFloat(anyFloat));
+        assertFalse(AnyConverter.isFloat(aDouble));
+    }
+
+    @Test public void test_isDouble() {
+        assertTrue(AnyConverter.isDouble(aDouble));
+        assertTrue(AnyConverter.isDouble(anyDouble));
+        assertFalse(AnyConverter.isDouble(aFloat));
+    }
+
+    @Test public void test_isObject() {
+        assertTrue(AnyConverter.isObject(aObj));
+        assertTrue(AnyConverter.isObject( new Any( XInterface.class, null)));
+        assertFalse(AnyConverter.isObject(new Object()));
+    }
+
+    @Test public void test_isString() {
+        assertTrue(AnyConverter.isString(aStr));
+        assertTrue(AnyConverter.isString(anyStr));
+        assertFalse(AnyConverter.isString(new Object()));
+    }
+
+    @Test public void test_isType() {
+        assertTrue(AnyConverter.isType(aType));
+        assertTrue(AnyConverter.isType(anyType));
+        assertFalse(AnyConverter.isType(new Object()));
+    }
+
+    @Test public void test_isArray() {
+        assertTrue(AnyConverter.isArray(arByte));
+        assertTrue(AnyConverter.isArray(anyArByte));
+        assertFalse(AnyConverter.isArray(new Object()));
+    }
+
+    @Test public void test_isVoid() {
+        assertTrue(AnyConverter.isVoid(anyVoid));
+        assertFalse(AnyConverter.isVoid(new Object()));
+    }
+}
+
+
+class ATypeProvider implements com.sun.star.lang.XTypeProvider
+{
+
+    public byte[] getImplementationId()
+    {
+        return new byte[0];
+    }
+
+    public com.sun.star.uno.Type[] getTypes()
+    {
+        return new Type[]{new Type(XTypeProvider.class)};
+    }
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/uno/Any_Test.java b/ridljar/test/com/sun/star/uno/Any_Test.java
new file mode 100644
index 000000000..6dc3a15b1
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/Any_Test.java
@@ -0,0 +1,48 @@
+/*
+ * 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 com.sun.star.uno;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class Any_Test {
+
+    private static final Logger logger = Logger.getLogger(Any_Test.class.getName());
+
+    @Test public void testAnyAny() {
+        try {
+            new Any(Type.ANY, null);
+            fail("IllegalArgumentException expected");
+        } catch (IllegalArgumentException e) {
+            logger.log(Level.FINE, "IllegalArgumentException caught");
+        }
+    }
+
+    @Test public void testComplete() {
+        assertSame(Any.VOID, Any.complete(Any.VOID));
+        assertEquals(
+            new Any(Type.LONG, Integer.valueOf(10)), Any.complete(Integer.valueOf(10)));
+        assertEquals(
+            new Any(new Type(XInterface.class), null), Any.complete(null));
+        XInterface x = new XInterface() {};
+        assertEquals(new Any(new Type(XInterface.class), x), Any.complete(x));
+    }
+}
diff --git a/ridljar/test/com/sun/star/uno/Type_Test.java b/ridljar/test/com/sun/star/uno/Type_Test.java
new file mode 100644
index 000000000..1499b8230
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/Type_Test.java
@@ -0,0 +1,104 @@
+/*
+ * 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 com.sun.star.uno;
+
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class Type_Test {
+    @Test public void testZClass() {
+        assertSame("VOID", void.class, new Type("void").getZClass());
+        assertSame("BOOLEAN", boolean.class, new Type("boolean").getZClass());
+        assertSame("BYTE", byte.class, new Type("byte").getZClass());
+        assertSame("SHORT", short.class, new Type("short").getZClass());
+        assertSame(
+            "UNSIGNED SHORT", short.class,
+            new Type("unsigned short").getZClass());
+        assertSame("LONG", int.class, new Type("long").getZClass());
+        assertSame(
+            "UNSIGNED LONG", int.class, new Type("unsigned long").getZClass());
+        assertSame("HYPER", long.class, new Type("hyper").getZClass());
+        assertSame(
+            "UNSIGNED HYPER", long.class,
+            new Type("unsigned hyper").getZClass());
+        assertSame("FLOAT", float.class, new Type("float").getZClass());
+        assertSame("DOUBLE", double.class, new Type("double").getZClass());
+        assertSame("CHAR", char.class, new Type("char").getZClass());
+        assertSame("STRING", String.class, new Type("string").getZClass());
+        assertSame("TYPE", Type.class, new Type("type").getZClass());
+        assertSame("ANY", Object.class, new Type("any").getZClass());
+        assertSame(
+            "sequence of BOOLEAN", boolean[].class,
+            new Type("[]boolean", TypeClass.SEQUENCE).getZClass());
+        assertSame(
+            "sequence of sequence of XComponentContext",
+            XComponentContext[][].class,
+            new Type("[][]com.sun.star.uno.XComponentContext", TypeClass.SEQUENCE).getZClass());
+        assertSame(
+            "enum TypeClass", TypeClass.class,
+            new Type("com.sun.star.uno.TypeClass", TypeClass.ENUM).getZClass());
+        assertSame(
+            "struct Uik", Uik.class,
+            new Type("com.sun.star.uno.Uik", TypeClass.STRUCT).getZClass());
+        assertSame(
+            "exception Exception", com.sun.star.uno.Exception.class,
+            new Type("com.sun.star.uno.Exception", TypeClass.EXCEPTION).getZClass());
+        assertSame(
+            "exception RuntimeException",
+            com.sun.star.uno.RuntimeException.class,
+            new Type("com.sun.star.uno.RuntimeException", TypeClass.EXCEPTION).getZClass());
+        assertSame(
+            "exception DeploymentException", DeploymentException.class,
+            new Type("com.sun.star.uno.DeploymentException", TypeClass.EXCEPTION).getZClass());
+        assertSame(
+            "interface XInterface", XInterface.class,
+            new Type("com.sun.star.uno.XInterface", TypeClass.INTERFACE).getZClass());
+        assertSame(
+            "interface XComponentContext", XComponentContext.class,
+            new Type("com.sun.star.uno.XComponentContext", TypeClass.INTERFACE). getZClass());
+
+        assertSame(boolean.class, new Type(boolean.class).getZClass());
+        assertSame(boolean.class, new Type(Boolean.class).getZClass());
+        assertSame(boolean[].class, new Type(boolean[].class).getZClass());
+
+        try {
+            new Type(Boolean[].class);
+            fail();
+        } catch (java.lang.RuntimeException e) {}
+    }
+
+    @Test public void testIsSupertypeOf() {
+        Type ifc = new Type(com.sun.star.uno.XInterface.class);
+        Type ctx = new Type(com.sun.star.uno.XComponentContext.class);
+        Type exc = new Type(com.sun.star.uno.RuntimeException.class);
+        assertTrue("LONG :> LONG", Type.LONG.isSupertypeOf(Type.LONG));
+        assertFalse("not ANY :> XInterface", Type.ANY.isSupertypeOf(ifc));
+        assertTrue("ANY :> ANY", Type.ANY.isSupertypeOf(Type.ANY));
+        assertFalse("not ANY :> LONG", Type.ANY.isSupertypeOf(Type.LONG));
+        assertFalse("not XInterface :> ANY", ifc.isSupertypeOf(Type.ANY));
+        assertTrue("XInterface :> XInterface", ifc.isSupertypeOf(ifc));
+        assertTrue("XInterface :> XComponentContext", ifc.isSupertypeOf(ctx));
+        assertFalse(
+            "not XComponentContext :> XInterface", ctx.isSupertypeOf(ifc));
+        assertTrue(
+            "XComponentContext :> XComponentContext", ctx.isSupertypeOf(ctx));
+        assertFalse(
+            "not XInterface :> RuntimeException", ifc.isSupertypeOf(exc));
+    }
+}
diff --git a/ridljar/test/com/sun/star/uno/UnoRuntime_EnvironmentTest.java b/ridljar/test/com/sun/star/uno/UnoRuntime_EnvironmentTest.java
new file mode 100644
index 000000000..b10adf12e
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/UnoRuntime_EnvironmentTest.java
@@ -0,0 +1,85 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.uno;
+
+import com.sun.star.comp.connections.PipedConnection;
+import org.junit.Test;
+import util.WaitUnreachable;
+import static org.junit.Assert.*;
+
+public final class UnoRuntime_EnvironmentTest {
+    @Test public void test_getEnvironment() throws java.lang.Exception {
+        Object o1 = new Object();
+        Object o2 = new Object();
+
+        // get two environments with different contexts
+        WaitUnreachable java_environment1 = new WaitUnreachable(
+            UnoRuntime.getEnvironment("java", o1));
+        WaitUnreachable java_environment2 = new WaitUnreachable(
+            UnoRuntime.getEnvironment("java", o2));
+
+        // ensure that the environments are different
+        assertNotSame(java_environment1.get(), java_environment2.get());
+
+        // test if we get the same environment when we reget it
+        assertTrue(
+            UnoRuntime.areSame(
+                java_environment1.get(),
+                UnoRuntime.getEnvironment("java", o1)));
+        assertTrue(
+            UnoRuntime.areSame(
+                java_environment2.get(),
+                UnoRuntime.getEnvironment("java", o2)));
+
+        // drop the environments and wait until they are gc
+        java_environment1.waitUnreachable();
+        java_environment2.waitUnreachable();
+    }
+
+    @Test public void test_getBridge() throws java.lang.Exception {
+        PipedConnection conn = new PipedConnection(new Object[0]);
+        new PipedConnection(new Object[] { conn });
+
+        // get a bridge
+        IBridge iBridge = UnoRuntime.getBridgeByName(
+            "java", null, "remote", "testname",
+            new Object[] { "urp", conn, null });
+
+        // reget the bridge, it must be the same as above
+        IBridge iBridge_tmp = UnoRuntime.getBridgeByName(
+            "java", null, "remote", "testname",
+            new Object[] { "urp", conn, null });
+        assertTrue(UnoRuntime.areSame(iBridge_tmp, iBridge));
+
+        // dispose the bridge, this removes the entry from the runtime
+        iBridge.dispose();
+
+        conn = new PipedConnection(new Object[0]);
+        new PipedConnection(new Object[] { conn });
+
+        // reget the bridge, it must be a different one
+        iBridge_tmp = UnoRuntime.getBridgeByName(
+            "java", null, "remote", "testname",
+            new Object[]{ "urp", conn, null });
+        assertFalse(UnoRuntime.areSame(iBridge_tmp, iBridge));
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/ridljar/test/com/sun/star/uno/UnoRuntime_Test.java b/ridljar/test/com/sun/star/uno/UnoRuntime_Test.java
new file mode 100644
index 000000000..fb2afe8ae
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/UnoRuntime_Test.java
@@ -0,0 +1,196 @@
+/*
+ * 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 com.sun.star.uno;
+
+import com.sun.star.beans.Optional;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public final class UnoRuntime_Test {
+    @Test public void test_generateOid() {
+        // Test if UnoRuntime generates an OID for a simple class:
+        assertNotNull("Test1", UnoRuntime.generateOid(new Test1()));
+
+        // Test if UnoRuntime generates an OID for a class implementing
+        // IQueryInterface and returning null from getOid:
+        assertNotNull("Test2", UnoRuntime.generateOid(new Test2()));
+
+        // Test if a delegator object has the same OID as its creator:
+        Test4 test4 = new Test4();
+        Ifc ifc = UnoRuntime.queryInterface(Ifc.class, test4);
+        assertEquals(
+            "Test4", UnoRuntime.generateOid(ifc),
+            UnoRuntime.generateOid(test4));
+    }
+
+    @Test public void test_queryInterface() {
+        // Test if a query for an interface which is not supported returns null:
+        assertNull("Test1", UnoRuntime.queryInterface(Ifc.class, new Test1()));
+
+        // Test if a query for an interface which is supported through
+        // IQueryInterface succeeds:
+        assertNotNull(
+            "Test2", UnoRuntime.queryInterface(Ifc.class, new Test2()));
+
+        // Test if a query for an interface which is directly supported (through
+        // inheritance) succeeds:
+        assertNotNull(
+            "Test3", UnoRuntime.queryInterface(Ifc.class, new Test3()));
+    }
+
+    @Test public void test_areSame() {
+        assertTrue(
+            UnoRuntime.areSame(
+                new Any(Type.UNSIGNED_LONG, Integer.valueOf(3)),
+                new Any(Type.UNSIGNED_LONG, Integer.valueOf(3))));
+        assertFalse(
+            UnoRuntime.areSame(
+                new Any(Type.UNSIGNED_LONG, Integer.valueOf(3)), Integer.valueOf(3)));
+        assertFalse(UnoRuntime.areSame(new int[] { 1 }, new int[] { 1, 2 }));
+        assertTrue(
+            UnoRuntime.areSame(
+                TypeClass.UNSIGNED_LONG,
+                new Any(new Type(TypeClass.class), TypeClass.UNSIGNED_LONG)));
+        assertTrue(
+            UnoRuntime.areSame(
+                new Any(
+                    new Type("com.sun.star.beans.Optional<unsigned long>"),
+                    new Optional<Integer>()),
+                new Any(
+                    new Type("com.sun.star.beans.Optional<unsigned long>"),
+                    new Optional<Integer>(false, Integer.valueOf(0)))));
+        assertFalse(UnoRuntime.areSame(new Test1(), new Test2()));
+        Test2 test2 = new Test2();
+        assertTrue(
+            "Test2",
+            UnoRuntime.areSame(
+                UnoRuntime.queryInterface(Ifc.class, test2), test2));
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Test public void test_completeValue() {
+        assertEquals(
+            Integer.valueOf(0), UnoRuntime.completeValue(Type.UNSIGNED_LONG, null));
+        Object v = UnoRuntime.completeValue(
+            new Type("[][]unsigned long"), null);
+        assertTrue(v instanceof int[][]);
+        assertEquals(0, ((int[][]) v).length);
+        assertSame(
+            TypeClass.VOID,
+            UnoRuntime.completeValue(new Type(TypeClass.class), null));
+        v = UnoRuntime.completeValue(
+            new Type("com.sun.star.beans.Optional<unsigned long>"), null);
+        assertTrue(v instanceof Optional);
+        assertFalse(((Optional) v).IsPresent);
+        assertNull(((Optional) v).Value);
+    }
+
+    @Test public void test_currentContext() throws InterruptedException {
+        TestThread t1 = new TestThread();
+        TestThread t2 = new TestThread();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        Object v1 = t1.context.getValueByName("");
+        Object v2 = t2.context.getValueByName("");
+        assertFalse(t1.context == t2.context);
+        assertSame(v1, t1);
+        assertSame(v2, t2);
+        assertNotSame(v1, v2);
+    }
+
+    private interface Ifc extends XInterface {}
+
+    private static class Test1 {}
+
+    private static class Test2 implements XInterface, IQueryInterface {
+        public String getOid() {
+            return null;
+        }
+
+        public Object queryInterface(Type type) {
+            return type.equals(new Type(Ifc.class)) ? t2 : null;
+        }
+
+        public boolean isSame(Object object) {
+            return object == t2;
+        }
+
+        private static final class T2 implements Ifc {}
+
+        private final T2 t2 = new T2();
+    }
+
+    private static class Test3 implements Ifc {}
+
+    private static class Test4 implements XInterface, IQueryInterface {
+        public String getOid() {
+            return null;
+        }
+
+        public Object queryInterface(Type type) {
+            return type.equals(new Type(Ifc.class)) ? t4 : null;
+        }
+
+        public boolean isSame(Object object) {
+            return object == t4;
+        }
+
+        private final class T4 implements Ifc, IQueryInterface {
+            public String getOid() {
+                return UnoRuntime.generateOid(Test4.this);
+            }
+
+            public Object queryInterface(Type type) {
+                return Test4.this.queryInterface(type);
+            }
+
+            public boolean isSame(Object object) {
+                return UnoRuntime.areSame(Test4.this, object);
+            }
+        }
+
+        private final T4 t4 = new T4();
+    }
+
+    private final class TestThread extends Thread {
+        @Override
+        public void run() {
+            //TODO: JUnit does not notice if these asserts fail:
+            assertNull(UnoRuntime.getCurrentContext());
+            context = new TestCurrentContext();
+            UnoRuntime.setCurrentContext(context);
+            assertSame(context, UnoRuntime.getCurrentContext());
+            assertSame(this, context.getValueByName(""));
+            UnoRuntime.setCurrentContext(null);
+            assertNull(UnoRuntime.getCurrentContext());
+        }
+
+        public XCurrentContext context = null;
+    }
+
+    private static final class TestCurrentContext implements XCurrentContext {
+        public Object getValueByName(String name) {
+            return value;
+        }
+
+        private final Object value = Thread.currentThread();
+    }
+}
diff --git a/ridljar/test/com/sun/star/uno/WeakReference_Test.java b/ridljar/test/com/sun/star/uno/WeakReference_Test.java
new file mode 100644
index 000000000..960c05dad
--- /dev/null
+++ b/ridljar/test/com/sun/star/uno/WeakReference_Test.java
@@ -0,0 +1,107 @@
+/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 com.sun.star.uno;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import org.junit.Test;
+import util.WaitUnreachable;
+import static org.junit.Assert.*;
+
+public final class WeakReference_Test {
+    @Test public void test() {
+        Object o = new MockWeak();
+        WeakReference r1 = new WeakReference(o);
+        WeakReference r2 = new WeakReference(r1);
+        assertSame(o, r1.get());
+        assertSame(o, r2.get());
+        WaitUnreachable u = new WaitUnreachable(o);
+        o = null;
+        u.waitUnreachable();
+        assertNull("a3", r1.get());
+        assertNull("a4", r2.get());
+    }
+
+    private static final class MockWeak implements XWeak {
+        public XAdapter queryAdapter() {
+            return adapter;
+        }
+
+        @Override
+        protected void finalize() throws Throwable {
+            adapter.dispose();
+            super.finalize();
+        }
+
+        private static final class Adapter implements XAdapter {
+            public Adapter(Object obj) {
+                ref = new java.lang.ref.WeakReference<Object>(obj);
+            }
+
+            public Object queryAdapted() {
+                return ref.get();
+            }
+
+            public void addReference(XReference ref) {
+                synchronized (this) {
+                    if (listeners != null) {
+                        listeners.add(ref);
+                        return;
+                    }
+                }
+                ref.dispose();
+            }
+
+            public synchronized void removeReference(XReference ref) {
+                if (listeners != null) {
+                    listeners.remove(ref);
+                }
+            }
+
+            public void dispose() {
+                ArrayList<XReference> l;
+                synchronized (this){
+                    l = listeners;
+                    listeners = null;
+                }
+                if (l != null) {
+                    java.lang.RuntimeException ex = null;
+                    for (Iterator<XReference> i = l.iterator(); i.hasNext();) {
+                        try {
+                            i.next().dispose();
+                        } catch (java.lang.RuntimeException e) {
+                            ex = e;
+                        }
+                    }
+                    if (ex != null) {
+                        throw ex;
+                    }
+                }
+            }
+
+            private final java.lang.ref.WeakReference<Object> ref;
+            private ArrayList<XReference> listeners = new ArrayList<XReference>();
+        }
+
+        private final Adapter adapter = new Adapter(this);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */