From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 11:06:44 +0200
Subject: Adding upstream version 4:7.4.7.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../ifc/registry/_XImplementationRegistration.java | 184 ++++++++++
 .../tests/java/ifc/registry/_XSimpleRegistry.java  | 405 +++++++++++++++++++++
 2 files changed, 589 insertions(+)
 create mode 100644 qadevOOo/tests/java/ifc/registry/_XImplementationRegistration.java
 create mode 100644 qadevOOo/tests/java/ifc/registry/_XSimpleRegistry.java

(limited to 'qadevOOo/tests/java/ifc/registry')

diff --git a/qadevOOo/tests/java/ifc/registry/_XImplementationRegistration.java b/qadevOOo/tests/java/ifc/registry/_XImplementationRegistration.java
new file mode 100644
index 000000000..7603f8a00
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/registry/_XImplementationRegistration.java
@@ -0,0 +1,184 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+package ifc.registry;
+
+import com.sun.star.registry.XImplementationRegistration;
+import com.sun.star.registry.XSimpleRegistry;
+import com.sun.star.uno.RuntimeException;
+import lib.MultiMethodTest;
+import util.RegistryTools;
+import util.utils;
+
+/**
+* Testing <code>com.sun.star.registry.XImplementationRegistration</code>
+* interface methods :
+* <ul>
+*  <li><code> registerImplementation()</code></li>
+*  <li><code> revokeImplementation()</code></li>
+*  <li><code> getImplementations()</code></li>
+*  <li><code> checkInstantiation()</code></li>
+* </ul> <p>
+* The following predefined files needed to complete the test:
+* <ul>
+*  <li> <code>solibrary.jar</code> : jar file with implementation
+*   classes. One of the required implementation must have name
+*   <code>com.ivistaportal.solibrary.HistogramImpl</code> cause
+*   it is checked in <code>getImplementations</code> method. </li>
+* <ul> <p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* After test completion object environment has to be recreated.
+* @see com.sun.star
+*/
+public class _XImplementationRegistration extends MultiMethodTest {
+
+    public XImplementationRegistration oObj = null;
+
+    private String url = null ;
+    private String loader = null ;
+    private XSimpleRegistry reg = null ;
+
+    /**
+    * First a registry created and opened in the temporary directory
+    * of StarOffice. Then some implementations situated in JAR file
+    * is registered in the registry opened. <p>
+    * Has <b>OK</b> status if some information is written into registry.
+    *
+    */
+    public void _registerImplementation()
+        throws RuntimeException
+    {
+        url = util.utils.getFullTestURL("qadevlibs/MyPersistObjectImpl.jar");
+        loader = "com.sun.star.loader.Java2";
+        boolean result = false ;
+        String name = null;
+
+        try {
+            name = utils.getOfficeTempDir(tParam.getMSF()) +
+                "XImplementationRegistration_tmp.rdb";
+            reg = RegistryTools.openRegistry
+                (name, tParam.getMSF()) ;
+
+            oObj.registerImplementation(loader, url, reg) ;
+
+            RegistryTools.printRegistryInfo(reg.getRootKey(), log) ;
+
+            String[] subKeys = reg.getRootKey().getKeyNames() ;
+
+            result = subKeys != null && subKeys.length > 0 ;
+
+        } catch (com.sun.star.uno.Exception e) {
+            log.println("Can't open registry file: " + name) ;
+            e.printStackTrace(log) ;
+        }
+        tRes.tested("registerImplementation()", result) ;
+    }
+
+    /**
+    * Retrieves an array of implementation names and check them. <p>
+    * Has <b>OK</b> status if among them an implementation name
+    * <code>com.ivistaportal.solibrary.HistogramImpl</code> exists.
+    * The following method tests are to be completed successfully before :
+    * <ul>
+    *  <li> <code> registerImplementation </code>  </li>
+    * </ul>
+    */
+    public void _getImplementations() throws RuntimeException{
+        requiredMethod("registerImplementation()") ;
+
+        String[] impl = oObj.getImplementations(loader, url) ;
+
+        if (impl.length == 0) log.println("getImplementations() "+
+            "returns an empty array");
+        boolean result = false ;
+        log.println("Implementations found :") ;
+        for (int i = 0; i < impl.length; i++) {
+            log.println(" '" + impl[i] + "'") ;
+            if ("com.sun.star.cmp.MyPersistObject".
+                equals(impl[i])) {
+
+                result = true ;
+                break ;
+            }
+        }
+
+
+
+        tRes.tested("getImplementations()", result) ;
+    }
+
+    /**
+    * Calls the method with
+    * <code>com.sun.star.comp.stoc.JavaComponentLoader</code>
+    * implementation name.<p>
+    * Has <b>OK</b> status if not null array returned. <p>
+    * The following method tests are to be completed successfully before :
+    * <ul>
+    *  <li> <code> registerImplementation </code>  </li>
+    * </ul>
+    */
+    public void _checkInstantiation() throws RuntimeException {
+        requiredMethod("registerImplementation()") ;
+
+        String[] inst = oObj.checkInstantiation(
+            "com.sun.star.comp.stoc.JavaComponentLoader") ;
+
+        tRes.tested("checkInstantiation()", inst != null) ;
+    }
+
+    /**
+    * Revokes implementations from registry, and checks if
+    * all implementations' information is deleted. <p>
+    * Has <b>OK</b> status if registry has no key entries. <p>
+    * The following method tests are to be completed successfully before :
+    * <ul>
+    *  <li> <code> registerImplementation </code> : to have
+    *   implementation registered in registry. </li>
+    * </ul>
+    * The following method tests are to be executed before :
+    * <ul>
+    *  <li> <code> getImplementations </code>
+    *  <li> <code> checkInstantiation </code>
+    * </ul>
+    */
+    public void _revokeImplementation() throws RuntimeException{
+        requiredMethod("registerImplementation()") ;
+
+        executeMethod("getImplementations()") ;
+        executeMethod("checkInstantiation()") ;
+
+        oObj.revokeImplementation(url, reg);
+        RegistryTools.printRegistryInfo(reg, log) ;
+
+        try {
+            reg.getRootKey().getKeyNames();
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            log.println("!!! Exception retrieving keys from registry :") ;
+            e.printStackTrace(log);
+        }
+
+        tRes.tested("revokeImplementation()", true) ;
+    }
+
+    @Override
+    public void after() {
+        this.disposeEnvironment() ;
+    }
+}
+
+
diff --git a/qadevOOo/tests/java/ifc/registry/_XSimpleRegistry.java b/qadevOOo/tests/java/ifc/registry/_XSimpleRegistry.java
new file mode 100644
index 000000000..93dfeb533
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/registry/_XSimpleRegistry.java
@@ -0,0 +1,405 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+package ifc.registry;
+
+import lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+import util.RegistryTools;
+
+import com.sun.star.registry.InvalidRegistryException;
+import com.sun.star.registry.XRegistryKey;
+import com.sun.star.registry.XSimpleRegistry;
+
+
+/**
+* Testing <code>com.sun.star.registry.XSimpleRegistry</code>
+* interface methods :
+* <ul>
+*  <li><code> getURL()</code></li>
+*  <li><code> open()</code></li>
+*  <li><code> isValid()</code></li>
+*  <li><code> close()</code></li>
+*  <li><code> destroy()</code></li>
+*  <li><code> getRootKey()</code></li>
+*  <li><code> isReadOnly()</code></li>
+*  <li><code> mergeKey()</code></li>
+* </ul> <p>
+* This test needs the following object relations :
+* <ul>
+*  <li> <code>'NR'</code> <b>optional</b> (of type <code>String</code>):
+*   if this object relation isn't null than the testing component
+*   doesn't support some methods of the interface
+*   (<code>open(), close(), destroy()</code>)</li>
+*  <li> <code>'XSimpleRegistry.open'</code> (of type <code>String</code>):
+*    The full system path to the registry file which is opened and modified.
+*  </li>
+*  <li> <code>'XSimpleRegistry.destroy'</code> (of type <code>String</code>):
+*    The full system path to the registry file which is destroyed.
+*  </li>
+*  <li> <code>'XSimpleRegistry.merge'</code> (of type <code>String</code>):
+*    The full system path to the registry file which is merged with the
+*    registry tested.
+*  </li>
+* </ul> <p>
+* @see com.sun.star.registry.XSimpleRegistry
+*/
+public class _XSimpleRegistry extends MultiMethodTest {
+    public XSimpleRegistry oObj = null;
+    protected String nr = null;
+    protected boolean configuration = false;
+    protected String openF = null;
+    protected String destroyF = null;
+    protected String mergeF = null;
+
+    /**
+    * Retrieves object relations.
+    * @throws StatusException If one of required relations not found.
+    */
+    @Override
+    protected void before() {
+        if (tEnv.getObjRelation("configuration") != null) {
+            configuration = true;
+        }
+
+        nr = (String) tEnv.getObjRelation("NR");
+
+        openF = (String) tEnv.getObjRelation("XSimpleRegistry.open");
+
+        if (openF == null) {
+            throw new StatusException(Status.failed(
+                                              "Relation 'XSimpleRegistry.open' not found"));
+        }
+
+        destroyF = (String) tEnv.getObjRelation("XSimpleRegistry.destroy");
+
+        if (destroyF == null) {
+            throw new StatusException(Status.failed(
+                                              "Relation 'XSimpleRegistry.destroy' not found"));
+        }
+
+        mergeF = (String) tEnv.getObjRelation("XSimpleRegistry.merge");
+
+        if (mergeF == null) {
+            throw new StatusException(Status.failed(
+                                              "Relation 'XSimpleRegistry.merge' not found"));
+        }
+    }
+
+    /**
+    * If the method is supported opens the registry key with the URL
+    * from <code>'XSimpleRegistry.open'</code> relation, then closes it. <p>
+    *
+    * Has <b> OK </b> status if the method isn't supported by the component
+    * (the object relation <code>'NR'</code> isn't null) or no exceptions were
+    * thrown during open/close operations. <p>
+    */
+    public void _open() {
+        if (nr != null) {
+            log.println("'open()' isn't supported by '" + nr + "'");
+            tRes.tested("open()", true);
+
+            return;
+        }
+
+        log.println("Trying to open registry :" + openF);
+
+        try {
+            oObj.open(openF, false, true);
+            oObj.close();
+        } catch (InvalidRegistryException e) {
+            e.printStackTrace(log);
+            tRes.tested("open()", false);
+
+            return;
+        }
+
+        tRes.tested("open()", true);
+    }
+
+    /**
+    * Test opens the registry key with the URL from
+    * <code>'XSimpleRegistry.open'</code> relation not only for read,
+    * calls the method, checks returned value and closes the registry. <p>
+    *
+    * Has <b> OK </b> status if returned value is false and no exceptions were
+    * thrown. <p>
+    */
+    public void _isReadOnly() {
+        boolean result = false;
+
+        try {
+            openReg(oObj, openF, false, true);
+            result = !oObj.isReadOnly();
+            closeReg(oObj);
+        } catch (InvalidRegistryException e) {
+            e.printStackTrace(log);
+            result = false;
+        }
+
+        tRes.tested("isReadOnly()", result);
+    }
+
+    /**
+    * Test opens the registry key with the URL from
+    * <code>'XSimpleRegistry.open'</code> relation, calls the method,
+    * checks returned value and closes the registry key. <p>
+    *
+    * Has <b>OK</b> status if returned value isn't null and no exceptions were
+    * thrown. <p>
+    */
+    public void _getRootKey() {
+        boolean result = false;
+
+        try {
+            openReg(oObj, openF, false, true);
+
+            XRegistryKey rootKey = oObj.getRootKey();
+            result = rootKey != null;
+            closeReg(oObj);
+        } catch (InvalidRegistryException e) {
+            e.printStackTrace(log);
+            result = false;
+        }
+
+        tRes.tested("getRootKey()", result);
+    }
+
+    /**
+    * Merges the current registry with the registry from URL got from
+    * <code>'XSimpleRegistry.merge'</code> relation under 'MergeKey' key.
+    * Then the keys of these two registries retrieved :
+    * <ul>
+    *  <li> Root key from 'XSimpleRegistry.merge' registry </li>
+    *  <li> 'MergeKey' key from the current registry </li>
+    * </ul>
+    * Then these two keys are recursively compared. <p>
+    *
+    * Has <b> OK </b> status if the method isn't supported by the component
+    * (the object relation <code>'NR'</code> isn't null)
+    * or
+    * if it's supported and after successful merging the keys mentioned
+    * above are recursively equal. <p>
+    */
+    public void _mergeKey() {
+        if (configuration) {
+            log.println(
+                    "You can't merge into this registry. It's just a wrapper for a configuration node, which has a fixed structure which can not be modified");
+            tRes.tested("mergeKey()", true);
+
+            return;
+        }
+
+        if (nr != null) {
+            log.println("'mergeKey()' isn't supported by '" + nr + "'");
+            tRes.tested("mergeKey()", true);
+
+            return;
+        }
+
+        openReg(oObj, openF, false, true);
+
+        try {
+            RegistryTools.printRegistryInfo(oObj.getRootKey(), log);
+            oObj.mergeKey("MergeKey", mergeF);
+            RegistryTools.printRegistryInfo(oObj.getRootKey(), log);
+        } catch (com.sun.star.registry.MergeConflictException e) {
+            e.printStackTrace(log);
+            tRes.tested("mergeKey()", false);
+
+            return;
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            e.printStackTrace(log);
+            tRes.tested("mergeKey()", false);
+
+            return;
+        }
+
+        boolean isEqual = false;
+        XSimpleRegistry reg = null;
+
+        try {
+            reg = RegistryTools.createRegistryService(tParam.getMSF());
+        } catch (com.sun.star.uno.Exception e) {
+            log.print("Can't create registry service: ");
+            e.printStackTrace(log);
+            tRes.tested("mergeKey()", false);
+
+            return;
+        }
+
+        openReg(reg, mergeF, false, true);
+
+        try {
+            XRegistryKey key = oObj.getRootKey().openKey("MergeKey");
+            XRegistryKey mergeKey = reg.getRootKey();
+            isEqual = RegistryTools.compareKeyTrees(key, mergeKey);
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            log.print("Can't get root key: ");
+            e.printStackTrace(log);
+            tRes.tested("mergeKey()", false);
+
+            return;
+        }
+
+        closeReg(reg);
+        closeReg(oObj);
+
+        tRes.tested("mergeKey()", isEqual);
+    }
+
+    /**
+    * Test opens the registry key with the URL from
+    * <code>'XSimpleRegistry.open'</code> relation, calls the method,
+    * checks returned value and closes the registry key. <p>
+    *
+    * Has <b> OK </b> status if returned value isn't null and if length of the
+    * returned string is greater than 0. <p>
+    */
+    public void _getURL() {
+        openReg(oObj, openF, false, true);
+
+        String url = oObj.getURL();
+        closeReg(oObj);
+        log.println("Getting URL: " + url+";");
+        tRes.tested("getURL()", (url != null));
+    }
+
+    /**
+    * Test checks value returned by the object relation <code>'NR'</code>,
+    * opens the registry key with the URL from
+    * <code>XSimpleRegistry.open'</code> relation, calls the method
+    * and checks the validity of the registry key. <p>
+    *
+    * Has <b> OK </b> status if the registry key isn't valid after the method
+    * call, or if the method isn't supported by the component (the object
+    * relation <code>'NR'</code> isn't null). <p>
+    */
+    public void _close() {
+        if (nr != null) {
+            log.println("'close()' isn't supported by '" + nr + "'");
+            tRes.tested("close()", true);
+
+            return;
+        }
+
+        try {
+            oObj.open(openF, false, true);
+            oObj.close();
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            e.printStackTrace(log);
+            tRes.tested("close()", false);
+
+            return;
+        }
+
+        tRes.tested("close()", !oObj.isValid());
+    }
+
+    /**
+    * Test checks value returned by the object relation <code>'NR'</code>,
+    * opens the registry key with the URL from
+    * <code>'XSimpleRegistry.destroy'</code> relation, calls the method
+    * and checks the validity of the registry key. <p>
+    *
+    * Has <b> OK </b> status if the registry key isn't valid after the method
+    * call, or if the method isn't supported by the component (the object
+    * relation <code>'NR'</code> isn't null). <p>
+    */
+    public void _destroy() {
+        if (configuration) {
+            log.println(
+                    "This registry is a wrapper for a configuration access. It can not be destroyed.");
+            tRes.tested("destroy()", true);
+
+            return;
+        }
+
+        if (nr != null) {
+            log.println("'destroy()' isn't supported by '" + nr + "'");
+            tRes.tested("destroy()", true);
+
+            return;
+        }
+
+        try {
+            oObj.open(destroyF, false, true);
+            oObj.destroy();
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            e.printStackTrace(log);
+            tRes.tested("destroy()", false);
+
+            return;
+        }
+
+        tRes.tested("destroy()", !oObj.isValid());
+    }
+
+    /**
+    * Test opens the registry key with the URL from
+    * <code>'XSimpleRegistry.open'</code> relation, calls the method,
+    * checks returned value and closes the registry key. <p>
+    * Has <b> OK </b> status if returned value is true. <p>
+    */
+    public void _isValid() {
+        boolean valid = true;
+
+        openReg(oObj, openF, false, true);
+        valid = oObj.isValid();
+        closeReg(oObj);
+
+        tRes.tested("isValid()", valid);
+    }
+
+    /**
+    * Method calls <code>close()</code> of the interface
+    * <code>com.sun.star.registry.XRegistryKey</code>. <p>
+    * @param reg interface <code>com.sun.star.registry.XRegistryKey</code>
+    * @param url specifies the complete URL to access the data source
+    * @param arg1 specifies if the data source should be opened for read only
+    * @param arg2 specifies if the data source should be created if it does not
+    * already exist
+    */
+    public void openReg(XSimpleRegistry reg, String url, boolean arg1,
+                        boolean arg2) {
+        if (nr == null) {
+            try {
+                reg.open(url, arg1, arg2);
+            } catch (com.sun.star.registry.InvalidRegistryException e) {
+                log.print("Couldn't open registry:");
+                e.printStackTrace(log);
+            }
+        }
+    }
+
+    /**
+    * Method calls <code>close()</code> of the interface
+    * <code>com.sun.star.registry.XRegistryKey</code>. <p>
+    * @param reg <code>com.sun.star.registry.XRegistryKey</code>
+    */
+    public void closeReg(XSimpleRegistry reg) {
+        if (nr == null) {
+            try {
+                reg.close();
+            } catch (com.sun.star.registry.InvalidRegistryException e) {
+                log.print("Couldn't close registry:");
+                e.printStackTrace(log);
+            }
+        }
+    }
+}
-- 
cgit v1.2.3