| /************************************************************** |
| * |
| * 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.ucb; |
| |
| import lib.MultiMethodTest; |
| import lib.Status; |
| import lib.StatusException; |
| |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.ucb.ContentProviderInfo; |
| import com.sun.star.ucb.DuplicateProviderException; |
| import com.sun.star.ucb.XContentProvider; |
| import com.sun.star.ucb.XContentProviderManager; |
| import com.sun.star.uno.Exception; |
| import com.sun.star.uno.UnoRuntime; |
| |
| /** |
| * Tests XContentProviderManager. The test registers two ContentProviders, calls |
| * queryXXX methods to verify results, and deregisters them. |
| * |
| * Testing <code>com.sun.star.ucb.XContentProviderManager</code> |
| * interface methods : |
| * <ul> |
| * <li><code> registerContentProvider()</code></li> |
| * <li><code> deregisterContentProvider()</code></li> |
| * <li><code> queryContentProviders()</code></li> |
| * <li><code> queryContentProvider()</code></li> |
| * </ul> <p> |
| * The test registers two ContentProviders, calls |
| * queryXXX methods to verify results, and deregisters them. <p> |
| * |
| * Test is <b> NOT </b> multithread compilant. <p> |
| * @see com.sun.star.ucb.XContentProviderManager |
| */ |
| public class _XContentProviderManager extends MultiMethodTest { |
| /** |
| * Contains the tested object. |
| */ |
| public XContentProviderManager oObj; |
| |
| /** |
| * The test scheme name. |
| */ |
| static final String myScheme = "test-scheme"; |
| |
| /** |
| * First content provider. It will be hidden by <code>contentProvider |
| * </code>, registred with the same <code>myScheme</code> to test |
| * the "hiding" behaviour. |
| */ |
| XContentProvider firstContentProvider; |
| |
| /** |
| * The main content provider. |
| */ |
| XContentProvider contentProvider; |
| |
| /** |
| * <code>ContentProvider</code>s information which are in the manager |
| * before registering the testing providers. |
| */ |
| ContentProviderInfo[] initialProvidersInfo; |
| |
| /** |
| * Creates two testing providers. |
| * |
| * @see #firstContentProvider |
| * @see #contentProvider |
| */ |
| public void before() { |
| XMultiServiceFactory xMSF = (XMultiServiceFactory)tParam.getMSF(); |
| |
| log.println("creating testing content providers"); |
| try { |
| firstContentProvider = (XContentProvider)UnoRuntime.queryInterface( |
| XContentProvider.class, xMSF.createInstance( |
| "com.sun.star.ucb.FileContentProvider")); |
| |
| contentProvider = (XContentProvider)UnoRuntime.queryInterface( |
| XContentProvider.class, xMSF.createInstance( |
| "com.sun.star.ucb.FileContentProvider")); |
| } catch (Exception e) { |
| log.println("Can't create content providers " + e.getMessage()); |
| e.printStackTrace(log); |
| throw new StatusException("Unexpected exception", e); |
| } |
| } |
| |
| /** |
| * At the beginning call <code>queryContentProviders</code> method |
| * |
| * to have info about providers existing before new adding. |
| * It adds two testing contents providers, both for the same scheme. |
| * The second one is added two times: first, in non-replacing mode, to test |
| * <code>DuplicateProviderException</code>, and second, in replacing mode, |
| * to hide the first provider. <p> |
| * |
| * The evaluation of results are performed later, in |
| * <code>queryContentProvider()</code>. |
| * |
| * Has <b> OK </b> status if in the first provider is registered |
| * without exceptions, the second throws |
| * <code>DuplicateProviderException</code> in non-replacing mode, |
| * and no exceptions in replacing mode. <p> |
| * |
| * @see #_queryContentProvider |
| */ |
| public void _registerContentProvider() { |
| // querying providfers info before inserting them, to verify results |
| initialProvidersInfo = oObj.queryContentProviders(); |
| |
| log.println("registering the first provider"); |
| try { |
| oObj.registerContentProvider(firstContentProvider, myScheme,false); |
| } catch (DuplicateProviderException e) { |
| log.println("Unexpected exception thrown " + e.getMessage()); |
| e.printStackTrace(log); |
| throw new StatusException("Unexpected exception ", e); |
| } |
| |
| log.println("registering the second provider in non-replacing mode"); |
| try { |
| oObj.registerContentProvider(contentProvider, myScheme, false); |
| Status.failed("registerContentProvider(.., .., false)"); |
| } catch (DuplicateProviderException e) { |
| log.println("DuplicateProviderException thrown - OK"); |
| } |
| |
| XContentProvider result; |
| |
| log.println("registering the second provider in the replace mode"); |
| try { |
| result = oObj.registerContentProvider(contentProvider, myScheme, true); |
| } catch (DuplicateProviderException e) { |
| log.println("Unexpected exception thrown " + e.getMessage()); |
| e.printStackTrace(log); |
| throw new StatusException("Unexpected exception ", e); |
| } |
| |
| // check the result is the first provider |
| tRes.tested("registerContentProvider()", |
| result.equals(firstContentProvider)); |
| } |
| |
| /** |
| * It calls the method (after registering providers) and compares |
| * its result with the result before registering. |
| * |
| * Has <b> OK </b> status if the number of providers increases |
| * by one after registering custom provider. |
| * |
| * The following method tests are to be completed successfully before : |
| * <ul> |
| * <li> <code> registerContentProvider() </code> : to compare number |
| * of providers. </li> |
| * </ul> |
| * @see #_registerContentProvider |
| */ |
| public void _queryContentProviders() { |
| executeMethod("registerContentProvider()"); |
| |
| ContentProviderInfo[] providersInfo = oObj.queryContentProviders(); |
| // verifying that the number of providers increased by 1 |
| tRes.tested("queryContentProviders()", |
| providersInfo.length == initialProvidersInfo.length + 1); |
| } |
| |
| /** |
| * It queries for added custom provider using its scheme |
| * and verifies its result with |
| * <code>queryContentProviders()</code> result and with |
| * custom provider created in <code>registerContentProvider()</code>. |
| * Also verifies <code>registerContentProvider()</code>. <p> |
| * |
| * Has <b>OK</b> status if the provider returned is found within |
| * all providers and is equal to provider created before. |
| * |
| * The following method tests are to be completed successfully before : |
| * <ul> |
| * <li> <code> registerContentProvider() </code> </li> |
| * </ul> |
| */ |
| public void _queryContentProvider() { |
| executeMethod("registerContentProvider()"); |
| |
| XContentProvider result = oObj.queryContentProvider |
| ("http://www.sun.com"); |
| |
| log.println("finding queryContentProvider() result"); |
| boolean found = false; |
| |
| ContentProviderInfo[] providersInfo = oObj.queryContentProviders(); |
| |
| for (int i = 0; i < providersInfo.length; i++) { |
| if (result.equals(providersInfo[i].ContentProvider) |
| /*&& myScheme.equals(providersInfo[i].Scheme)*/) { |
| found = true; |
| break; |
| } |
| } |
| |
| // boolean gotTheRightOne = util.ValueComparer.equalValue |
| // (result,contentProvider); |
| |
| tRes.tested("queryContentProvider()", found); |
| |
| // gotTheRightOne = result.equals(contentProvider); |
| |
| } |
| |
| /** |
| * At first one provider is deregistered, after that provider |
| * is queried, the second provider must be returned for the |
| * specified scheme. Then the second provider is deregistered. |
| * Now <code>null</code> value must be retruned by the method |
| * <code>queryContentProvider</code> on the specified scheme. <p> |
| * |
| * Has <b>OK</b> status if in the first case the second provider |
| * remains registered, and after its removing no providers remain |
| * registered for the scheme specified. |
| * |
| * The following method tests are to be completed successfully before : |
| * <ul> |
| * <li> <code> registerContentProvider() </code> : two providers |
| * must be registered. </li> |
| * </ul> |
| * The following method tests are to be executed before : |
| * <ul> |
| * <li> <code> queryContentProvider() </code> : to run this test |
| * finally. </li> |
| * <li> <code> queryContentProviders() </code> : to run this test |
| * finally. </li> |
| * </ul> |
| */ |
| public void _deregisterContentProvider() { |
| executeMethod("queryContentProvider()"); |
| executeMethod("queryContentProviders()"); |
| requiredMethod("registerContentProvider()"); |
| |
| log.println("deregistering the second provider"); |
| oObj.deregisterContentProvider(contentProvider, myScheme); |
| |
| XContentProvider res = oObj.queryContentProvider(myScheme); |
| |
| log.println("deregistering the first provider"); |
| oObj.deregisterContentProvider(firstContentProvider, myScheme); |
| |
| res = oObj.queryContentProvider(myScheme); |
| |
| // verifying that no provider is returned |
| tRes.tested("deregisterContentProvider()", res == null); |
| } |
| } |