| /************************************************************** |
| * |
| * 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 com.sun.star.lib.uno.helper; |
| |
| import com.sun.star.uno.XInterface; |
| import java.util.Iterator; |
| import java.util.ListIterator; |
| import com.sun.star.uno.Type; |
| import com.sun.star.uno.XWeak; |
| import com.sun.star.lang.XTypeProvider; |
| import com.sun.star.lang.XEventListener; |
| import java.util.ArrayList; |
| import com.sun.star.lang.XMultiComponentFactory; |
| import com.sun.star.uno.XComponentContext; |
| import com.sun.star.comp.helper.Bootstrap; |
| import com.sun.star.bridge.XUnoUrlResolver; |
| import com.sun.star.uno.UnoRuntime; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.lang.XSingleServiceFactory; |
| import com.sun.star.uno.IQueryInterface; |
| //import com.sun.star.lib.uno.environments.java.IRequester; |
| import com.sun.star.bridge.XBridge; |
| //import com.sun.star.lib.uno.environments.java.Proxy; |
| import com.sun.star.lib.uno.environments.java.java_environment; |
| import com.sun.star.lib.uno.typedesc.TypeDescription; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| |
| public class InterfaceContainer_Test |
| { |
| java_environment env= new java_environment(null); |
| /** Creates a new instance of InterfaceContainerTest */ |
| AWeakBase obj1,obj2,obj3,obj4; |
| Object proxyObj1Weak1; |
| Object proxyObj3Weak1; |
| Object proxyObj3Weak2; |
| Object proxyObj3TypeProv; |
| Object proxyObj2TypeProv; |
| //contains original objects |
| List list1; |
| //contains original objects + proxies |
| List list2; |
| //contains original object + proxies + null value |
| List list3; |
| |
| public InterfaceContainer_Test() |
| { |
| obj1= new AWeakBase(); |
| obj2= new AWeakBase(); |
| obj3= new AWeakBase(); |
| obj4= new AWeakBase(); |
| proxyObj1Weak1= ProxyProvider.createProxy(obj1, XWeak.class); |
| proxyObj3Weak1= ProxyProvider.createProxy(obj3, XWeak.class); |
| proxyObj3Weak2= ProxyProvider.createProxy(obj3, XWeak.class); |
| proxyObj2TypeProv= ProxyProvider.createProxy(obj2, XTypeProvider.class); |
| proxyObj3TypeProv= ProxyProvider.createProxy(obj3, XTypeProvider.class); |
| |
| list1= new ArrayList(); |
| list1.add(obj1); |
| list1.add(obj2); |
| list1.add(obj3); |
| list2= new ArrayList(); |
| list2.add(obj1); |
| list2.add(proxyObj2TypeProv); |
| list2.add(proxyObj3TypeProv); |
| list3= new ArrayList(); |
| list3.add(obj1); |
| list3.add(null); |
| list3.add(proxyObj2TypeProv); |
| list3.add(proxyObj3Weak1); |
| } |
| |
| /** Tests add(object), size(), clear(); |
| */ |
| public boolean add() |
| { |
| System.out.println("Testing List.add(Object), List.size(), List.clear(), List.isEmpty()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| r[i++]= cont.size() == 0; |
| r[i++]= cont.add(obj1); |
| r[i++]= cont.size() == 1; |
| r[i++]= cont.add(obj1); // add the same object again |
| r[i++]= cont.size() == 2; |
| r[i++]= cont.add(proxyObj3TypeProv); |
| r[i++]= cont.size() == 3; |
| r[i++]= cont.isEmpty() ? false: true; |
| cont.clear(); |
| r[i++]= cont.size() == 0; |
| r[i++]= cont.isEmpty(); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /**Tests list.addAll(Collection c), list.addAll(int index, Collection c) |
| */ |
| public boolean listConstructors() |
| { |
| System.out.println("Testing Constructors of InterfaceContainer"); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| InterfaceContainer cont= new InterfaceContainer(100); |
| |
| r[i++]= cont.elementData.length == 100; |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| public boolean trimToSize() |
| { |
| System.out.println("Testing InterfaceContainer.trimToSize"); |
| InterfaceContainer cont= new InterfaceContainer(100); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| cont.trimToSize(); |
| r[i++]= cont.isEmpty(); |
| cont= new InterfaceContainer(10); |
| cont.addAll(list1); |
| cont.trimToSize(); |
| r[i++]= cont.elementData.length == list1.size(); |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| public boolean ensureCapacity() |
| { |
| System.out.println("Testing InterfaceContainer.ensureCapacity"); |
| InterfaceContainer cont= new InterfaceContainer(10); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.ensureCapacity(9); |
| r[i++]= cont.elementData.length >= 9; |
| cont.ensureCapacity(11); |
| r[i++]= cont.elementData.length >= 11; |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean addAll() |
| { |
| System.out.println("Testing List.addAll(Collection c), List.addAll(int index, Collection c)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| r[i++]= cont.addAll(list1); |
| r[i++]= cont.size() == list1.size(); |
| for (int c= 0; c < cont.size(); c++) |
| { |
| r[i++]= list1.get(c) == cont.get(c); |
| } |
| cont.add(obj1); |
| r[i++]= cont.addAll(1, list2); |
| r[i++]= cont.get(0) == list1.get(0); |
| r[i++]= cont.get(1) == list2.get(0); |
| r[i++]= cont.get(2) == list2.get(1); |
| r[i++]= cont.get(3) == list2.get(2); |
| r[i++]= cont.get(4) == list1.get(1); |
| r[i++]= cont.get(5) == list1.get(2); |
| r[i++]= cont.get(6) == obj1; |
| cont.clear(); |
| cont.addAll(list3); |
| // the null element in list3 at index 1 is not added to cont |
| r[i++]= cont.get(0) == list3.get(0); |
| r[i++]= cont.get(1) == list3.get(2); |
| r[i++]= cont.get(2) == list3.get(3); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /** Tests List.add(int index, Object element), List.get(int index) |
| */ |
| public boolean get() |
| { |
| System.out.println("Testing List.add(int index, Object element), List.get(int index)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.add(0, obj1); |
| cont.add(1, obj2); |
| cont.add(1, proxyObj3Weak1); |
| cont.add(3, obj3); |
| r[i++]= cont.get(0) == obj1; |
| r[i++]= cont.get(1) == proxyObj3Weak1; |
| r[i++]= cont.get(2) == obj2; |
| r[i++]= cont.get(3) == obj3; |
| try |
| { |
| cont.add(5, obj1); |
| }catch( java.lang.Exception e) |
| { |
| r[i++]= true; |
| } |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| /** Tests List.contains |
| */ |
| public boolean contains() |
| { |
| System.out.println("Testing List.contains()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| r[i++]= cont.contains(obj1) ? false : true; // nothing in the list |
| cont.add(obj1); |
| cont.add(proxyObj2TypeProv); |
| cont.add(proxyObj3TypeProv); |
| r[i++]= cont.contains(obj1); |
| r[i++]= cont.contains(obj2); |
| r[i++]= cont.contains(proxyObj3Weak1); |
| r[i++]= cont.contains(proxyObj3Weak2); |
| r[i++]= cont.contains(proxyObj1Weak1); |
| r[i++]= cont.contains(obj3); |
| r[i++]= cont.contains(null) ? false : true; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| /** Tests List.containsAll |
| */ |
| public boolean containsAll() |
| { |
| System.out.println("Testing List.containsAll"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| cont.addAll(list1); |
| r[i++]= cont.containsAll(list1); |
| cont.clear(); |
| cont.addAll(list2); |
| r[i++]= cont.containsAll(list2); |
| cont.clear(); |
| cont.addAll(list3); // the null element in list3 is not added to cont |
| r[i++]= cont.containsAll(list3) ? false : true; |
| cont.clear(); |
| for( int x= 0; x < 6; x++) |
| cont.add(obj4); |
| r[i++]= cont.contains(list1) ? false : true; |
| cont.add(1, list1.get(0)); |
| cont.add(3, list1.get(1)); |
| cont.add(5, list1.get(2)); |
| r[i++]= cont.contains(list1) ? false : true; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| /** Tests List.indexOf, List.lastIndexOf |
| */ |
| public boolean indexOf() |
| { |
| System.out.println("Testing List.indexOf(Object element), List.lastIndexOf(Object element)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| cont.addAll(list1); |
| cont.addAll(list1); |
| r[i++]= cont.indexOf(obj3) == 2; |
| r[i++]= cont.lastIndexOf(obj3) == 5; |
| cont.clear(); |
| cont.addAll(list2); |
| cont.addAll(list2); |
| r[i++]= cont.indexOf(proxyObj3Weak1) == 2; |
| r[i++]= cont.lastIndexOf(proxyObj3Weak2) == 5; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /** Tests List.remove(int index), List.remove(Object element), List.removeAll(Collection c) |
| */ |
| public boolean remove() |
| { |
| System.out.println("Testing List.remove(int index), List.remove(Object element), List.removeAll(Collection c)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.addAll(list2); |
| r[i++]= proxyObj2TypeProv.equals(cont.remove(1)); |
| r[i++]= cont.size() == 2; |
| cont.clear(); |
| cont.addAll(list2); |
| r[i++]= cont.remove(obj1); |
| r[i++]= cont.remove(proxyObj2TypeProv); |
| r[i++]= cont.remove(proxyObj3Weak2); |
| r[i++]= cont.isEmpty(); |
| cont.clear(); |
| cont.addAll(list3); |
| r[i++]= cont.removeAll(list3); |
| r[i++]= cont.isEmpty(); |
| cont.addAll(list2); |
| |
| List list= new ArrayList(); |
| list.add(list2.get(0)); |
| list.add(list2.get(1)); |
| list.add(proxyObj3Weak2); |
| r[i++]= cont.removeAll(list); |
| r[i++]= cont.isEmpty(); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /** Tests List.retainAll |
| */ |
| public boolean retainAll() |
| { |
| System.out.println("Testing List.retainAll(Collection c)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.addAll(list1); //obj1, obj2, obj3 |
| cont.addAll(list2); //obj1, proxyObj2TypeProv, proxyObj3TypeProv |
| List list = new ArrayList(); |
| list.add(obj1); |
| list.add(proxyObj3Weak1); |
| |
| r[i++]= cont.retainAll(list); |
| r[i++]= cont.get(0) == obj1; |
| r[i++]= cont.get(1) == obj3; |
| r[i++]= cont.get(2) == obj1; |
| r[i++]= cont.get(3) == proxyObj3TypeProv; |
| r[i++]= 4 == cont.size(); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /** Tests List.set(int index, Object element) |
| **/ |
| public boolean set() |
| { |
| System.out.println("Testing List.set(int index, Object element)"); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| InterfaceContainer cont= new InterfaceContainer(); |
| cont.addAll(list2); |
| Object o1= cont.set(0, obj3); |
| Object o2= cont.set(2, proxyObj3Weak1); |
| r[i++]= o1 == list2.get(0); |
| r[i++]= o2 == list2.get(2); |
| r[i++]= cont.get(0) == obj3; |
| r[i++]= cont.get(2) == proxyObj3Weak1; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| /** Tests List.toArray(), List.toArray(Object[] a) |
| */ |
| public boolean toArray() |
| { |
| System.out.println("Testing List.toArray(), List.toArray(Object[] a)"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.addAll(list1); |
| Object[] ar= cont.toArray(); |
| Object[] arOrig= list1.toArray(); |
| r[i++]= ar.length == arOrig.length; |
| |
| r[i]= true; |
| for (int c= 0; c < ar.length; c++) |
| r[i]= r[i] && ar[c] == arOrig[c]; |
| |
| i++; |
| XWeak[] arWeak= new XWeak[3]; |
| XWeak[] arWeak2= (XWeak[])cont.toArray(arWeak); |
| r[i++]= ar.length == arWeak2.length; |
| r[i]= true; |
| for (int c= 0; c < ar.length; c++) |
| r[i]= r[i] && ar[c] == arWeak2[c]; |
| |
| i++; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean Iterator_next() |
| { |
| System.out.println("Testing InterfaceContainer.iterator, Iterator.next()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.addAll(list1); |
| Iterator it= cont.iterator(); |
| r[i++]= it.next() == list1.get(0); |
| r[i++]= it.next() == list1.get(1); |
| r[i++]= it.next() == list1.get(2); |
| try |
| { |
| it.next(); |
| }catch(java.util.NoSuchElementException ne) |
| { |
| r[i++]= true; |
| }catch(Exception e) |
| { |
| r[i++]= false; |
| } |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean Iterator_hasNext() |
| { |
| System.out.println("Testing, Iterator.next()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| Iterator it= cont.iterator(); |
| r[i++]= ! it.hasNext(); |
| cont.addAll(list1); |
| it= cont.iterator(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= ! it.hasNext(); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean Iterator_remove() |
| { |
| System.out.println("Testing, Iterator.remove()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| Iterator it= cont.iterator(); |
| try |
| { |
| it.remove(); |
| } |
| catch( IllegalStateException ie) |
| { |
| r[i++]= true; |
| } |
| catch(java.lang.Exception e) |
| { |
| r[i++]= false; |
| } |
| cont.add(obj1); |
| it= cont.iterator(); |
| it.next(); |
| it.remove(); |
| r[i++]= cont.isEmpty(); |
| try |
| { |
| it.remove(); |
| } |
| catch (IllegalStateException ie) |
| { |
| r[i++]= true; |
| } |
| catch (Exception e) |
| { |
| r[i++]= false; |
| } |
| cont.clear(); |
| cont.addAll(list1); |
| it= cont.iterator(); |
| while (it.hasNext()) |
| { |
| it.next(); |
| it.remove(); |
| } |
| r[i++]= cont.isEmpty(); |
| |
| // 2 iterators, remove must not impair the other iterator |
| cont.clear(); |
| cont.addAll(list1); |
| int size= cont.size(); |
| it= cont.iterator(); |
| Iterator it2= cont.iterator(); |
| while (it.hasNext()) |
| { |
| it.next(); |
| it.remove(); |
| } |
| try |
| { |
| for( int c= 0; c < size; c++) |
| it2.next(); |
| r[i++]= true; |
| } |
| catch(Exception e) |
| { |
| r[i++]= false; |
| } |
| r[i++]= cont.size() == 0; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| public boolean ListIterator_next() |
| { |
| System.out.println("Testing InterfaceContainer.listIerator, ListIterator.next()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.addAll(list1); |
| Iterator it= cont.listIterator(); |
| r[i++]= it.next() == list1.get(0); |
| r[i++]= it.next() == list1.get(1); |
| r[i++]= it.next() == list1.get(2); |
| try |
| { |
| it.next(); |
| }catch(java.util.NoSuchElementException ne) |
| { |
| r[i++]= true; |
| }catch(Exception e) |
| { |
| r[i++]= false; |
| } |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean ListIterator_hasNext() |
| { |
| System.out.println("Testing ListIterator.hasNext()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| Iterator it= cont.listIterator(); |
| r[i++]= ! it.hasNext(); |
| cont.addAll(list1); |
| it= cont.listIterator(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= it.hasNext(); |
| it.next(); |
| r[i++]= ! it.hasNext(); |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean ListIterator_remove() |
| { |
| System.out.println("Testing ListIterator.remove()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| ListIterator it= cont.listIterator(); |
| try |
| { |
| it.remove(); |
| } |
| catch( IllegalStateException ie) |
| { |
| r[i++]= true; |
| } |
| catch(java.lang.Exception e) |
| { |
| r[i++]= false; |
| } |
| cont.add(obj1); |
| it= cont.listIterator(); |
| it.next(); |
| it.remove(); |
| r[i++]= cont.isEmpty(); |
| try |
| { |
| it.remove(); |
| } |
| catch (IllegalStateException ie) |
| { |
| r[i++]= true; |
| } |
| catch (Exception e) |
| { |
| r[i++]= false; |
| } |
| cont.clear(); |
| cont.addAll(list1); |
| it= cont.listIterator(); |
| while (it.hasNext()) |
| { |
| it.next(); |
| it.remove(); |
| } |
| r[i++]= cont.isEmpty(); |
| |
| // 2 iterators, remove must not impair the other iterator |
| cont.clear(); |
| cont.addAll(list1); |
| int size= cont.size(); |
| it= cont.listIterator(); |
| Iterator it2= cont.listIterator(); |
| while (it.hasNext()) |
| { |
| it.next(); |
| it.remove(); |
| } |
| try |
| { |
| for( int c= 0; c < size; c++) |
| it2.next(); |
| r[i++]= true; |
| } |
| catch(Exception e) |
| { |
| r[i++]= false; |
| } |
| r[i++]= cont.size() == 0; |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean ListIterator_hasPrevious() |
| { |
| System.out.println("Testing ListIterator.hasPrevious()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| ListIterator it= cont.listIterator(); |
| r[i++]= ! it.hasPrevious(); |
| cont.addAll(list1); |
| it= cont.listIterator(); |
| while (it.hasNext()) |
| { |
| it.next(); |
| r[i++]= it.hasPrevious(); |
| } |
| |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean ListIterator_previous() |
| { |
| System.out.println("Testing ListIterator.previous()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| boolean bOk= true; |
| |
| cont.addAll(list1); |
| // go to the end of our list and list1 |
| ListIterator it= cont.listIterator(); |
| while (it.hasNext()) |
| it.next(); |
| ListIterator it_list1= list1.listIterator(); |
| while (it_list1.hasNext()) |
| it_list1.next(); |
| |
| while (it.hasPrevious()) |
| { |
| r[i++]= it.previous() == it_list1.previous(); |
| } |
| try |
| { |
| it.previous(); |
| r[i++]= false; |
| } |
| catch (java.util.NoSuchElementException e) |
| { |
| r[i++]=true; |
| } |
| |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean ListIterator_nextIndex() |
| { |
| System.out.println("Testing ListIterator.nextIndex()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| boolean bOk= true; |
| |
| ListIterator it= cont.listIterator(); |
| cont.addAll(list1); |
| it= cont.listIterator(); |
| r[i++]= it.nextIndex() == 0; |
| it.next(); |
| r[i++]= it.nextIndex() == 1; |
| it.next(); |
| r[i++]= it.nextIndex() == 2; |
| |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| public boolean ListIterator_previousIndex() |
| { |
| System.out.println("Testing ListIterator.previousIndex()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| boolean bOk= true; |
| |
| ListIterator it= cont.listIterator(); |
| cont.addAll(list1); |
| it= cont.listIterator(); |
| while (it.hasNext()) |
| it.next(); |
| |
| r[i++]= it.previousIndex() == 2; |
| it.previous(); |
| r[i++]= it.previousIndex() == 1; |
| it.previous(); |
| r[i++]= it.previousIndex() == 0; |
| it.previous(); |
| |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| public boolean ListIterator_add() |
| { |
| System.out.println("Testing ListIterator.add()"); |
| InterfaceContainer cont= new InterfaceContainer(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| boolean bOk= true; |
| |
| ListIterator it= cont.listIterator(); |
| it.add(obj1); |
| r[i++]= cont.size() == 1; |
| it.add(obj2); |
| r[i++]= cont.size() == 2; |
| it.add(obj3); |
| r[i++]= it.previous() == obj3; |
| r[i++]= it.previous() == obj2; |
| r[i++]= it.previous() == obj1; |
| |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| public boolean disposeAndClear() |
| { |
| System.out.println("Testing InterfaceContainer.disposeAndClear"); |
| InterfaceContainer cont= new InterfaceContainer(10); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| |
| cont.add(obj1); |
| cont.add(obj2); |
| cont.add(obj3); |
| cont.add(proxyObj1Weak1); |
| cont.add(proxyObj3TypeProv); |
| System.out.println("Two proxies are called. Check the output:"); |
| cont.disposeAndClear(new com.sun.star.lang.EventObject()); |
| r[i++]= obj1.nDisposingCalled == 1; |
| r[i++]= obj2.nDisposingCalled == 1; |
| r[i++]= obj3.nDisposingCalled == 1; |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if (bOk == false) |
| System.out.println("Failed"); |
| else |
| System.out.println("Ok"); |
| return bOk; |
| } |
| |
| |
| public static void main(String[] args) |
| { |
| InterfaceContainer_Test test= new InterfaceContainer_Test(); |
| boolean r[]= new boolean[50]; |
| int i= 0; |
| r[i++]= test.listConstructors(); |
| r[i++]= test.trimToSize(); |
| r[i++]= test.ensureCapacity(); |
| r[i++]= test.add(); |
| r[i++]= test.indexOf(); |
| r[i++]= test.contains(); |
| r[i++]= test.containsAll(); |
| r[i++]= test.get(); |
| r[i++]= test.addAll(); |
| r[i++]= test.remove(); |
| r[i++]= test.retainAll(); |
| r[i++]= test.set(); |
| r[i++]= test.toArray(); |
| r[i++]= test.Iterator_next(); |
| r[i++]= test.Iterator_hasNext(); |
| r[i++]= test.Iterator_remove(); |
| r[i++]= test.ListIterator_next(); |
| r[i++]= test.ListIterator_hasNext(); |
| r[i++]= test.ListIterator_remove(); |
| r[i++]= test.ListIterator_hasPrevious(); |
| r[i++]= test.ListIterator_previous(); |
| r[i++]= test.ListIterator_nextIndex(); |
| r[i++]= test.ListIterator_previousIndex(); |
| r[i++]= test.ListIterator_add(); |
| r[i++]= test.disposeAndClear(); |
| boolean bOk= true; |
| for (int c= 0; c < i; c++) |
| bOk= bOk && r[c]; |
| if ( ! bOk ) |
| System.out.println("Test finished.\nErrors occured!!!"); |
| else |
| System.out.println("Test finished. \nNo errors."); |
| |
| } |
| |
| } |
