Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

1 files changed, 359 insertions, 0 deletions

diff --git a/qadevOOo/runner/util/RegistryTools.java b/qadevOOo/runner/util/RegistryTools.java
new file mode 100644
index 000000000..72ef5e743
--- /dev/null
+++ b/qadevOOo/runner/util/RegistryTools.java
@@ -0,0 +1,359 @@
+/*
+ * 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 util;
+
+// access the implementations via names
+import com.sun.star.uno.UnoRuntime;
+import java.io.PrintWriter ;
+
+import com.sun.star.registry.XRegistryKey ;
+import com.sun.star.registry.XSimpleRegistry ;
+import com.sun.star.registry.RegistryKeyType ;
+import com.sun.star.registry.RegistryValueType ;
+import com.sun.star.registry.InvalidRegistryException ;
+import com.sun.star.lang.XMultiServiceFactory ;
+import com.sun.star.uno.Exception;
+
+public class RegistryTools {
+
+    /**
+    * Creates 'com.sun.star.registry.SimpleRegistry'
+    * service.
+    * @param xMSF Multiservice factory.
+    * @return Service created.
+    */
+    public static XSimpleRegistry createRegistryService
+        (XMultiServiceFactory xMSF) throws com.sun.star.uno.Exception {
+
+        Object oInterface = xMSF.createInstance
+            ("com.sun.star.registry.SimpleRegistry");
+        return UnoRuntime.queryInterface (
+            XSimpleRegistry.class, oInterface) ;
+    }
+
+    /**
+    * Opens registry file for reading/writing. If file doesn't
+    * exist a new one created.
+    * @param file Registry file name.
+    * @param xMSF Multiservice factory.
+    * @return Opened registry.
+    */
+    public static XSimpleRegistry openRegistry
+        (String file, XMultiServiceFactory xMSF)
+        throws com.sun.star.uno.Exception {
+
+        XSimpleRegistry reg = createRegistryService(xMSF) ;
+
+        reg.open(file, false, true) ;
+
+        return reg ;
+    }
+
+    /**
+    * Compares two registry keys, their names, value
+    * types and values.
+    * return <code>true</code> if key names, value types
+    * and values are equal, else returns <code>false</code>.
+    */
+    private static boolean compareKeys
+        (XRegistryKey key1, XRegistryKey key2) {
+
+        if (key1 == null || key2 == null ||
+            !key1.isValid() || !key2.isValid())
+
+            return false ;
+
+        String keyName1 = getShortKeyName(key1.getKeyName()) ;
+        String keyName2 = getShortKeyName(key2.getKeyName()) ;
+
+        if (!keyName1.equals(keyName2)) return false ;
+
+        try {
+            if (key1.getValueType() != key2.getValueType()) return false ;
+        } catch (InvalidRegistryException e) {
+            return false ;
+        }
+
+        RegistryValueType type ;
+        try {
+            type = key1.getValueType() ;
+
+            if (type.equals(RegistryValueType.ASCII)) {
+                if (!key1.getAsciiValue().equals(key2.getAsciiValue()))
+                    return false ;
+            } else
+            if (type.equals(RegistryValueType.STRING)) {
+                if (!key1.getStringValue().equals(key2.getStringValue()))
+                    return false ;
+            } else
+            if (type.equals(RegistryValueType.LONG)) {
+                if (key1.getLongValue() != key2.getLongValue())
+                    return false ;
+            } else
+            if (type.equals(RegistryValueType.BINARY)) {
+                byte[] bin1 = key1.getBinaryValue() ;
+                byte[] bin2 = key2.getBinaryValue() ;
+                if (bin1.length != bin2.length)
+                    return false ;
+                for (int i = 0; i < bin1.length; i++)
+                    if (bin1[i] != bin2[i]) return false ;
+            } else
+            if (type.equals(RegistryValueType.ASCIILIST)) {
+                String[] list1 = key1.getAsciiListValue() ;
+                String[] list2 = key2.getAsciiListValue() ;
+                if (list1.length != list2.length)
+                    return false ;
+                for (int i = 0; i < list1.length; i++)
+                    if (!list1[i].equals(list2[i])) return false ;
+            } else
+            if (type.equals(RegistryValueType.STRINGLIST)) {
+                String[] list1 = key1.getStringListValue() ;
+                String[] list2 = key2.getStringListValue() ;
+                if (list1.length != list2.length)
+                    return false ;
+                for (int i = 0; i < list1.length; i++)
+                    if (!list1[i].equals(list2[i])) return false ;
+            } else
+            if (type.equals(RegistryValueType.LONGLIST)) {
+                int[] list1 = key1.getLongListValue() ;
+                int[] list2 = key2.getLongListValue() ;
+                if (list1.length != list2.length)
+                    return false ;
+                for (int i = 0; i < list1.length; i++)
+                    if (list1[i] != list2[i]) return false ;
+            }
+        } catch (Exception e) {
+            return false ;
+        }
+
+        return true ;
+    }
+
+    /**
+    * Gets name of the key relative to its parent.
+    * For example if full name of key is '/key1/subkey'
+    * short key name is 'subkey'
+    * @param keyName Full key name.
+    * @return Short key name.
+    */
+    private static String getShortKeyName(String keyName) {
+        if (keyName == null) return null ;
+        int idx = keyName.lastIndexOf('/') ;
+        if (idx < 0) return keyName ;
+        else return keyName.substring(idx + 1) ;
+    }
+
+    /**
+    * Compare all child keys.
+    * @param compareRoot If <code>true</code> method also
+    * compare root keys, if <code>false</code> it begins recursive
+    * comparing from children of root keys.
+    * @return <code>true</code> if keys and their sub keys are equal.
+    */
+    private static boolean compareKeyTrees
+        (XRegistryKey tree1, XRegistryKey tree2, boolean compareRoot) {
+
+        if (compareRoot && !compareKeys(tree1, tree2)) return false ;
+
+        try {
+            String[] keyNames1 = tree1.getKeyNames() ;
+            String[] keyNames2 = tree2.getKeyNames() ;
+
+            if (keyNames1 == null && keyNames2 == null) return true ;
+
+            if (keyNames1 == null || keyNames2 == null ||
+                keyNames2.length != keyNames1.length)
+                return false ;
+
+            for (int i = 0; i < keyNames1.length; i++) {
+
+                String keyName = getShortKeyName(keyNames1[i]) ;
+                XRegistryKey key2 = tree2.openKey(keyName) ;
+
+                if (key2 == null)
+                // key with the same name doesn't exist in the second tree
+                    return false ;
+
+                if (!tree1.getKeyType(keyName).equals(
+                     tree2.getKeyType(keyName)))
+                    return false ;
+
+                if (tree1.getKeyType(keyName).equals(
+                    RegistryKeyType.LINK)) {
+
+                    if (!getShortKeyName(tree1.getLinkTarget(keyName)).equals(
+                        getShortKeyName(tree2.getLinkTarget(keyName))))
+
+                        return false ;
+                } else {
+
+                    if (!compareKeyTrees(tree1.openKey(keyName),
+                          tree2.openKey(keyName), true)) return false ;
+                }
+            }
+        } catch (InvalidRegistryException e) {
+            return false ;
+        }
+
+        return true ;
+    }
+
+    /**
+    * Compare keys specified and all their child keys.
+    * @return <code>true</code> if keys and their sub keys are equal.
+    */
+    public static boolean compareKeyTrees
+        (XRegistryKey tree1, XRegistryKey tree2) {
+
+        return compareKeyTrees(tree1, tree2, false) ;
+    }
+
+    /**
+    * Prints to a specified output about all keys and subkeys information
+    * (key name, type, value, link target, attributes) recursively.
+    * @param reg Registry for which information is needed.
+    * @param out Output stream.
+    */
+    public static void printRegistryInfo(XSimpleRegistry reg, PrintWriter out) {
+        try {
+            printRegistryInfo(reg.getRootKey(), out) ;
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            out.println("!!! Can't open root registry key for info printing") ;
+        }
+    }
+
+    /**
+    * Prints to a specified output about all keys and subkeys information
+    * (key name, type, value, link target, attributes) recursively.
+    * @param root Key for which subkeys (and further) information is required.
+    * @param out Output stream.
+    */
+    public static void printRegistryInfo(XRegistryKey root, PrintWriter out) {
+        if (root == null) {
+            out.println("/(null)") ;
+            return ;
+        }
+
+        out.println("/") ;
+        try {
+            printTreeInfo(root, out, "  ") ;
+        } catch (com.sun.star.registry.InvalidRegistryException e) {
+            out.println("Exception accessing registry :") ;
+            e.printStackTrace(out) ;
+        }
+    }
+
+    private static void printTreeInfo(XRegistryKey key,
+        PrintWriter out, String margin)
+        throws com.sun.star.registry.InvalidRegistryException {
+
+        String[] subKeys = key.getKeyNames() ;
+
+        if (subKeys == null || subKeys.length == 0) return ;
+
+        for (int i = 0; i < subKeys.length; i++) {
+            printKeyInfo(key, subKeys[i], out, margin) ;
+            XRegistryKey subKey = key.openKey
+                (getShortKeyName(subKeys[i])) ;
+            printTreeInfo(subKey, out, margin + "  ") ;
+            subKey.closeKey() ;
+        }
+    }
+
+    private static void printKeyInfo(XRegistryKey parentKey,
+        String keyName, PrintWriter out, String margin)
+        throws com.sun.star.registry.InvalidRegistryException {
+
+        out.print(margin) ;
+        keyName = getShortKeyName(keyName) ;
+        XRegistryKey key = parentKey.openKey(keyName) ;
+        if (key != null)
+            out.print("/" + getShortKeyName(key.getKeyName()) + " ") ;
+        else {
+            out.println("(null)") ;
+            return ;
+        }
+
+        if (!key.isValid()) {
+            out.println("(not valid)") ;
+            return ;
+        }
+
+        if (key.isReadOnly()) {
+            out.print("(read only) ") ;
+        }
+
+        if (parentKey.getKeyType(keyName) == RegistryKeyType.LINK) {
+            out.println("(link to " + parentKey.getLinkTarget(keyName) + ")") ;
+            return ;
+        }
+
+        RegistryValueType type ;
+        try {
+            type = key.getValueType() ;
+
+            if (type.equals(RegistryValueType.ASCII)) {
+                out.println("[ASCII] = '" + key.getAsciiValue() + "'") ;
+            } else
+            if (type.equals(RegistryValueType.STRING)) {
+                out.println("[STRING] = '" + key.getStringValue() + "'") ;
+            } else
+            if (type.equals(RegistryValueType.LONG)) {
+                out.println("[LONG] = " + key.getLongValue()) ;
+            } else
+            if (type.equals(RegistryValueType.BINARY)) {
+                out.print("[BINARY] = {") ;
+                byte[] bin = key.getBinaryValue() ;
+                for (int i = 0; i < bin.length; i++)
+                    out.print(bin[i] + ",") ;
+                out.println("}") ;
+            } else
+            if (type.equals(RegistryValueType.ASCIILIST)) {
+                out.print("[ASCIILIST] = {") ;
+                String[] list = key.getAsciiListValue() ;
+                for (int i = 0; i < list.length; i++)
+                    out.print("'" + list[i] + "',") ;
+                out.println("}") ;
+            } else
+            if (type.equals(RegistryValueType.STRINGLIST)) {
+                out.print("[STRINGLIST] = {") ;
+                String[] list = key.getStringListValue() ;
+                for (int i = 0; i < list.length; i++)
+                    out.print("'" + list[i] + "',") ;
+                out.println("}") ;
+            } else
+            if (type.equals(RegistryValueType.LONGLIST)) {
+                out.print("[LONGLIST] = {") ;
+                int[] list = key.getLongListValue() ;
+                for (int i = 0; i < list.length; i++)
+                    out.print(list[i] + ",") ;
+                out.println("}") ;
+            } else {
+                out.println("") ;
+            }
+        } catch (com.sun.star.uno.Exception e) {
+            out.println("Exception occurred : ") ;
+            e.printStackTrace(out) ;
+        } finally {
+            key.closeKey() ;
+        }
+    }
+
+
+}