| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| package ifc.registry; |
| |
| import lib.MultiMethodTest; |
| import lib.Status; |
| import lib.StatusException; |
| import util.RegistryTools; |
| |
| import com.sun.star.lang.XMultiServiceFactory; |
| 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 fiel 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. |
| */ |
| 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 successfull 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((XMultiServiceFactory) 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); |
| } |
| } |
| } |
| } |