/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 1997-2009 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

package org.openide.util.lookup;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.lang.ref.WeakReference;

import java.lang.ref.Reference;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import javax.swing.ActionMap;

import javax.swing.InputMap;

import org.netbeans.junit.NbTestCase;

import org.openide.util.Lookup;

import org.openide.util.Lookup.Template;

import org.openide.util.LookupEvent;

import org.openide.util.LookupListener;

@SuppressWarnings("unchecked") // XXX ought to be corrected, just a lot of them

public class AbstractLookupBaseHid extends NbTestCase {

    private static AbstractLookupBaseHid running;

    /** instance content to work with */

    InstanceContent ic;

    /** the lookup to work on */

    protected Lookup instanceLookup;

    /** the lookup created to work with */

    private Lookup lookup;

    /** implementation of methods that can influence the behaviour */

    Impl impl;

    protected AbstractLookupBaseHid(String testName, Impl impl) {

        super(testName);

        if (impl == null && (this instanceof Impl)) {

            impl = (Impl)this;

        }

        this.impl = impl;

    }

    protected @Override void setUp() {

        this.ic = new InstanceContent ();

        beforeActualTest(getName());

        this.instanceLookup = createInstancesLookup (ic);

        this.lookup = createLookup (instanceLookup);

        running = this;

    }        

    protected @Override void tearDown() {

        running = null;

    }

    /** The methods to influence test behaviour */

    public static interface Impl {

        /** Creates the initial abstract lookup.

         */

        public Lookup createInstancesLookup (InstanceContent ic);

        /** Creates an lookup for given lookup. This class just returns 

         * the object passed in, but subclasses can be different.

         * @param lookup in lookup

         * @return a lookup to use

         */

        public Lookup createLookup (Lookup lookup);

        /** If the impl has any caches that would prevent the system

         * to not garbage collect correctly, then clear them now.

         */

        public void clearCaches ();

    }

    private Lookup createInstancesLookup (InstanceContent ic) {

        return impl.createInstancesLookup (ic);

    }

    private Lookup createLookup (Lookup lookup) {

        return impl.createLookup (lookup);

    }

    /** instances that we register */

    private static Object[] INSTANCES = new Object[] {

        new Integer (10), 

        new Object ()

    };

    /** Test if first is really first.

     */

    public void testFirst () {

        Integer i1 = 1;

        Integer i2 = 2;

        ic.add (i1);

        ic.add (i2);

        Integer found = lookup.lookup(Integer.class);

        if (found != i1) {

            fail ("First object is not first: " + found + " != " + i1);

        }

        List<Integer> list = new ArrayList<Integer>();

        list.add (i2);

        list.add (i1);

        ic.set (list, null);

        found = lookup.lookup (Integer.class);

        if (found != i2) {

            fail ("Second object is not first after reorder: " + found + " != " + i2);

        }

    }

    public void testToString() {

        String txt = lookup.toString();

        assertNotNull("Something is there", txt);

        assertTrue("Something2: " + txt, txt.length() > 0);

    }

    /** Tests ordering of items in the lookup.

    */

    public void testOrder () {

        addInstances (INSTANCES);

        if (INSTANCES[0] != lookup.lookup (INSTANCES[0].getClass ())) {

            fail ("First object in intances not found");

        }

        Iterator<?> all = lookup.lookupAll(Object.class).iterator();

        checkIterator ("Difference between instances added and found", all, Arrays.asList (INSTANCES));

    }

    /** Checks the reorder of items in lookup reflects the result.

     * Testing both classes and interfaces, because they are often treated

     * especially.

     */

    public void testReorder () {

        String s1 = "s2";

        String s2 = "s1";

        Runnable r1 = new Runnable () {

            public void run () {}

        };

        Runnable r2 = new Runnable () {

            public void run () {}

        };

        List<Object> l = new ArrayList<Object>();

        l.add (s1);

        l.add (s2);

        l.add (r1);

        l.add (r2);

        ic.set (l, null);

        assertEquals ("s1 is found", s1, lookup.lookup (String.class));

        assertEquals ("r1 is found", r1, lookup.lookup (Runnable.class));

        Collections.reverse (l);

        ic.set (l, null);

        assertEquals ("s2 is found", s2, lookup.lookup (String.class));

        assertEquals ("r2 is found", r2, lookup.lookup (Runnable.class));

    }

    /** Tries to set empty collection to the lookup.

     */

    public void testSetEmpty () {

        ic.add ("A serializable string");

        lookup.lookup (Serializable.class);

        ic.set (Collections.emptyList(), null);

    }

    /** Tests a more complex reorder on nodes.

     */

    public void testComplexReorder () {

        Integer i1 = 1;

        Long i2 = 2L;

        List<Object> l = new ArrayList<Object>();

        l.add (i1);

        l.add (i2);

        ic.set (l, null);

        assertEquals ("Find integer", i1, lookup.lookup (Integer.class));

        assertEquals ("Find long", i2, lookup.lookup (Long.class));

        assertEquals ("Find number", i1, lookup.lookup (Number.class));

        Collections.reverse (l);

        ic.set (l, null);

        assertEquals ("Find integer", i1, lookup.lookup (Integer.class));

        assertEquals ("Find long", i2, lookup.lookup (Long.class));

        assertEquals ("Find number", i2, lookup.lookup (Number.class));

    }

    /** Checks whether setPairs keeps the order.

     */

    public void testSetPairs () {

        // test setPairs method

        List<Object> li = new ArrayList<Object>();

        li.addAll (Arrays.asList (INSTANCES));

        ic.set (li, null);

        Lookup.Result<Object> res = lookup.lookupResult(Object.class);

        Iterator<?> all = res.allInstances().iterator();

        checkIterator ("Original order not kept", all, li);

        // reverse the order

        Collections.reverse (li);

        // change the pairs

        LL listener = new LL (res);

        res.addLookupListener (listener);

        ic.set (li, null);

        if (listener.getCount () != 1) {

            fail ("Result has not changed even we set reversed order");

        }

        all = res.allInstances ().iterator ();

        checkIterator ("Reversed order not kept", all, li);

    }

    /** Checks whether setPairs fires correct events.

     */

    public void testSetPairsFire () {

        // test setPairs method

        List<Object> li = new ArrayList<Object>();

        li.addAll (Arrays.asList (INSTANCES));

        ic.set (li, null);

        Lookup.Result<Integer> res = lookup.lookupResult(Integer.class);

        Iterator<?> all = res.allInstances().iterator();

        checkIterator ("Integer is not there", all, Collections.nCopies (1, INSTANCES[0]));

        // change the pairs

        LL listener = new LL (res);

        res.addLookupListener (listener);

        List<Object> l2 = new ArrayList<Object>(li);

        l2.remove (INSTANCES[0]);

        ic.set (l2, null);

        all = lookup.lookupAll(Object.class).iterator();

        checkIterator ("The removed integer is not noticed", all, l2);

        if (listener.getCount () != 1) {

            fail ("Nothing has not been fired");

        }

    }

    /** Checks whether set pairs does not fire when they should not.

    */

    public void testSetPairsDoesNotFire () {

        Object tmp = new Object ();

        List<Object> li = new ArrayList<Object>();

        li.add (tmp);

        li.addAll (Arrays.asList (INSTANCES));

        ic.set (li, null);

        Lookup.Result<Integer> res = lookup.lookupResult(Integer.class);

        Iterator<?> all = res.allInstances ().iterator ();

        checkIterator ("Integer is not there", all, Collections.nCopies (1, INSTANCES[0]));

        // change the pairs

        LL listener = new LL (res);

        res.addLookupListener (listener);

        List<Object> l2 = new ArrayList<Object>(li);

        l2.remove (tmp);

        ic.set (l2, null);

        all = lookup.lookupAll(Object.class).iterator();

        checkIterator ("The removed integer is not noticed", all, l2);

        if (listener.getCount () != 0) {

            fail ("Something has been fired");

        }

    }

    /** Test whether after registration it is possible to find registered objects

    * 

     */

    public void testLookupAndAdd () throws Exception {

        addInstances (INSTANCES);

        for (int i = 0; i < INSTANCES.length; i++) {

            Object obj = INSTANCES[i];

            findAll (lookup, obj.getClass (), true);

        }

    }

    /** Tries to find all classes and superclasses in the lookup.

    */

    private void findAll(Lookup lookup, Class<?> clazz, boolean shouldBeThere) {

        if (clazz == null) return;

        Object found = lookup.lookup (clazz);

        if (found == null) {

            if (shouldBeThere) {

                // should find at either instance or something else, but must

                // find at least something

                fail ("Lookup (" + clazz.getName () + ") found nothing");

            }

        } else {

            if (!shouldBeThere) {

                // should find at either instance or something else, but must

                // find at least something

                fail ("Lookup (" + clazz.getName () + ") found " + found);

            }

        }

        Lookup.Result<?> res = lookup.lookupResult(clazz);

        Collection<?> collection = res.allInstances();

        for (int i = 0; i < INSTANCES.length; i++) {

            boolean isSubclass = clazz.isInstance (INSTANCES[i]);

            boolean isThere = collection.contains (INSTANCES[i]);

            if (isSubclass != isThere) {

                // a problem found

                // should find at either instance or something else, but must

                // find at least something

                fail ("Lookup.Result (" + clazz.getName () + ") for " + INSTANCES[i] + " is subclass: " + isSubclass + " isThere: " + isThere);

            }

        }

        // go on for superclasses

        findAll (lookup, clazz.getSuperclass (), shouldBeThere);

        Class[] ies = clazz.getInterfaces ();

        for (int i = 0; i < ies.length; i++) {

            findAll (lookup, ies[i], shouldBeThere);

        }

    }

    /** Test if it is possible to remove a registered object. */

    public void testRemoveRegisteredObject() {

        Integer inst = new Integer(10);

        ic.add(inst);

        if (lookup.lookup(inst.getClass()) == null) {

            // should find an instance

            fail("Lookup (" + inst.getClass().getName () + ") found nothing");

        }

        ic.remove(inst);

        if (lookup.lookup(inst.getClass()) != null) {

            // should NOT find an instance

            fail("Lookup (" + inst.getClass().getName () +

                ") found an instance after remove operation");

        }

    }

    public void testCanReturnReallyStrangeResults () throws Exception {

        class QueryingPair extends AbstractLookup.Pair<Object> {

            private Integer i = 434;

            //

            // do the test

            //

            public void doTest () throws Exception {

                ic.add (i);

                ic.addPair (this);

                Object found = lookup.lookup (QueryingPair.class);

                assertEquals ("This object is found", this, found);

            }

            //

            // Implementation of pair

            // 

            public String getId() {

                return getType ().toString();

            }

            public String getDisplayName() {

                return getId ();

            }

            public Class<?> getType() {

                return getClass ();

            }

            protected boolean creatorOf(Object obj) {

                return obj == this;

            }

            protected boolean instanceOf(Class<?> c) {

                assertEquals ("Integer found or exception is thrown", i, lookup.lookup (Integer.class));

                return c.isAssignableFrom(getType ());

            }

            public Object getInstance() {

                return this;

            }

        }

        QueryingPair qp = new QueryingPair ();

        qp.doTest ();

    }

    /** Test of firing events. */

    public void testLookupListener() {

        Object inst = 10;

        Lookup.Result<?> res = lookup.lookupResult(inst.getClass());

        res.allInstances ();

        LL listener = new LL(res);

        res.addLookupListener(listener);

        ic.add(inst);

        if (listener.getCount() == 0) {

            fail("None event fired during NbLookup.addPair()");

        }

        ic.remove(inst);

        if (listener.getCount() == 0) {

            fail("None event fired during NbLookup.removePair()");

        }

        ic.add(inst);

        if (listener.getCount() == 0) {

            fail("None event fired during second NbLookup.addPair()");

        }

        ic.remove(inst);

        if (listener.getCount() == 0) {

            fail("None event fired during second NbLookup.removePair()");

        }

    }

    /** Testing identity of the lookup.

     */

    public void testId () {

        Lookup.Template<?> templ;

        int cnt;

        addInstances (INSTANCES);

        Lookup.Result<?> res = lookup.lookupResult(Object.class);

        for (AbstractLookup.Item<?> item : res.allItems()) {

            templ = new Lookup.Template<Object>(null, item.getId(), null);

            cnt = lookup.lookup (templ).allInstances ().size ();

            if (cnt != 1) {

                fail ("Identity lookup failed. Instances = " + cnt);

            }

            templ = makeTemplate(item.getType(), item.getId());

            cnt = lookup.lookup (templ).allInstances ().size ();

            if (cnt != 1) {

                fail ("Identity lookup with type failed. Instances = " + cnt);

            }

            templ = makeTemplate(this.getClass(), item.getId());

            cnt = lookup.lookup (templ).allInstances ().size ();

            if (cnt != 0) {

                fail ("Identity lookup with wrong type failed. Instances = " + cnt);

            }

            templ = new Lookup.Template<Object>(null, null, item.getInstance());

            cnt = lookup.lookup (templ).allInstances ().size ();

            if (cnt != 1) {

                fail ("Instance lookup failed. Instances = " + cnt);

            }

            templ = new Lookup.Template<Object>(null, item.getId(), item.getInstance());

            cnt = lookup.lookup (templ).allInstances ().size ();

            if (cnt != 1) {

                fail ("Instance & identity lookup failed. Instances = " + cnt);

            }

        }

    }

    private static <T> Lookup.Template<T> makeTemplate(Class<T> clazz, String id) { // captures type parameter

        return new Lookup.Template<T>(clazz, id, null);

    }

    /** Tests adding and removing.

     */

    public void testAddAndRemove () throws Exception {

        Object map = new javax.swing.ActionMap ();

        LL ll = new LL ();

        Lookup.Result<?> res = lookup.lookupResult(map.getClass());

        res.allItems();

        res.addLookupListener (ll);

        ll.source = res;

        ic.add (map);

        assertEquals ("First change when adding", ll.getCount (), 1);

        ic.remove (map);

        assertEquals ("Second when removing", ll.getCount (), 1);

        ic.add (map);

        assertEquals ("Third when readding", ll.getCount (), 1);

        ic.remove (map);

        assertEquals ("Forth when reremoving", ll.getCount (), 1);

    }

    /** Will a class garbage collect even it is registered in lookup.

     */

    public void testGarbageCollect () throws Exception {

        ClassLoader l = new CL ();

        Class<?> c = l.loadClass(Garbage.class.getName());

        Reference<?> ref = new WeakReference<Object>(c);

        lookup.lookup (c);

        // now test garbage collection

        c = null;

        l = null;

        impl.clearCaches ();

        assertGC ("The classloader has not been garbage collected!", ref);

    }

    /** Items are the same as results.

     */

    public void testItemsAndIntances () {

        addInstances (INSTANCES);

        Lookup.Result<Object> r = lookup.lookupResult(Object.class);

        Collection<? extends Lookup.Item<?>> items = r.allItems();

        Collection<?> insts = r.allInstances();

        if (items.size () != insts.size ()) {

            fail ("Different size of sets");

        }

        for (Lookup.Item<?> item : items) {

            if (!insts.contains (item.getInstance ())) {

                fail ("Intance " + item.getInstance () + " is missing in " + insts);

            }

        }

    }

    /** Checks search for interface.

     */

    public void testSearchForInterface () {

        Lookup.Template<Serializable> t = new Lookup.Template<Serializable>(Serializable.class, null, null);

        assertNull("Nothing to find", lookup.lookupItem (t));

        Serializable s = new Serializable () {};

        ic.add (s);

        Lookup.Item item = lookup.lookupItem (t);

        assertNotNull ("Something found", item);

    }

    /** Test to add broken item if it incorrectly answers instanceOf questions.

     */

    public void testIncorectInstanceOf40364 () {

        final Long sharedLong = new Long (0);

        class P extends AbstractLookup.Pair<Object> {

            public boolean isLong;

            P (boolean b) {

                isLong = b;

            }

            protected boolean creatorOf (Object obj) {

                return obj == sharedLong;

            }

            public String getDisplayName () {

                return "";

            }

            public String getId () {

                return "";

            }

            public Object getInstance () {

                return sharedLong;

            }

            public Class<?> getType() {

                return isLong ? Long.class : Number.class;

            }

            protected boolean instanceOf(Class<?> c) {

                return c.isAssignableFrom (getType ());

            }

            public @Override int hashCode() {

                return getClass ().hashCode ();

            }    

            public @Override boolean equals(Object obj) {

                return obj != null && getClass ().equals (obj.getClass ());

            }

        }

        // to create the right structure in the lookup

        lookup.lookup (Object.class);

        lookup.lookup (Long.class);

        lookup.lookup (Number.class);

        P lng1 = new P (true);

        ic.addPair (lng1);

        P lng2 = new P (false);

        ic.setPairs (Collections.singleton (lng2));

        Collection<? extends Lookup.Item<?>> res = lookup.lookupResult(Object.class).allItems();

        assertEquals ("Just one pair", 1, res.size ());

    }

    public void testAbsolutelyCrazyWayToSimulateIssue48590ByChangingTheBehaviourOfEqualOnTheFly () throws Exception {

        class X implements TestInterfaceInheritanceA, TestInterfaceInheritanceB {

        }

        final X shared = new X ();

        class P extends AbstractLookup.Pair<Object> {

            public int howLong;

            P (int b) {

                howLong = b;

            }

            protected boolean creatorOf (Object obj) {

                return obj == shared;

            }

            public String getDisplayName () {

                return "";

            }

            public String getId () {

                return "";

            }

            public Object getInstance () {

                return shared;

            }

            public Class<?> getType() {

                return howLong == 0 ? TestInterfaceInheritanceB.class : TestInterfaceInheritanceA.class;

            }

            protected boolean instanceOf(Class<?> c) {

                return c.isAssignableFrom (getType ());

            }

            public @Override int hashCode() {

                return getClass ().hashCode ();

            }    

            public @Override boolean equals(Object obj) {

                if (obj instanceof P) {

                    P p = (P)obj;

                    if (this.howLong > 0) {

                        this.howLong--;

                        return false;

                    }

                    if (p.howLong > 0) {

                        p.howLong--;

                        return false;

                    }

                    return getClass ().equals (p.getClass ());

                }

                return false;

            }

        }

        // to create the right structure in the lookup

        Lookup.Result<?> a = lookup.lookupResult(TestInterfaceInheritanceA.class);

        Lookup.Result<?> b = lookup.lookupResult(TestInterfaceInheritanceB.class);

        P lng1 = new P (0);

        ic.addPair (lng1);

        assertEquals ("One in a", 1, a.allItems ().size ());

        assertEquals ("One in b", 1, b.allItems ().size ());

        P lng2 = new P (1);

        /* Following call used to generate this exception:

    java.lang.IllegalStateException: Duplicate pair in treePair1:  pair2:  index1: 0 index2: 0 item1: org.openide.util.lookup.AbstractLookupBaseHid$1X@1a457b6 item2: org.openide.util.lookup.AbstractLookupBaseHid$1X@1a457b6 id1: 7a78d3 id2: 929206

	at org.openide.util.lookup.ALPairComparator.compare(ALPairComparator.java:52)

	at java.util.Arrays.mergeSort(Arrays.java:1284)

	at java.util.Arrays.sort(Arrays.java:1223)

	at java.util.Collections.sort(Collections.java:159)

	at org.openide.util.lookup.InheritanceTree.retainAllInterface(InheritanceTree.java:753)

	at org.openide.util.lookup.InheritanceTree.retainAll(InheritanceTree.java:183)

	at org.openide.util.lookup.DelegatingStorage.retainAll(DelegatingStorage.java:83)

	at org.openide.util.lookup.AbstractLookup.setPairsAndCollectListeners(AbstractLookup.java:238)

	at org.openide.util.lookup.AbstractLookup.setPairs(AbstractLookup.java:203)

	at org.openide.util.lookup.AbstractLookup$Content.setPairs(AbstractLookup.java:885)

	at org.openide.util.lookup.AbstractLookupBaseHid.testAbsolutelyCrazyWayToSimulateIssue48590ByChangingTheBehaviourOfEqualOnTheFly(AbstractLookupBaseHid.java:696)

	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)

	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)

	at org.netbeans.junit.NbTestCase.run(NbTestCase.java:119)

    */  

        ic.setPairs (Collections.singleton (lng2));

    }

    public void testInstancesArePreservedFoundWhenFixing48590 () throws Exception {

        class X implements Runnable, Serializable {

            public void run () {

            }

            public void assertOnlyMe (String msg, Lookup.Result<?> res) {

                Collection<?> col = res.allInstances();

                assertEquals (msg + " just one", 1, col.size ());

                assertSame (msg + " and it is me", this, col.iterator ().next ());

            }

        }

        Lookup.Result<?> runnable = lookup.lookupResult(Runnable.class);

        Lookup.Result<?> serial = lookup.lookupResult(Serializable.class);

        X x = new X ();

        ic.add (x);

        x.assertOnlyMe ("x implements it (1)", runnable);

        x.assertOnlyMe ("x implements it (2)", serial);

        ic.set (Collections.singleton (x), null);

        x.assertOnlyMe ("x implements it (3)", runnable);

        x.assertOnlyMe ("x implements it (4)", serial);

    }

    /** Testing lookup of inherited classes. */

    public void testInheritance() {

        class A {}

        class B extends A implements java.rmi.Remote {}

        class BB extends B {}

        class C extends A implements java.rmi.Remote {}

        class D extends A {}

        A[] types = {new B(), new BB(), new C(), new D()};

        for (int i = 0; i < types.length; i++) {

            ic.add(types[i]);

            if (lookup.lookup(types[i].getClass()) == null) {

                // should find an instance

                fail("Lookup (" + types[i].getClass().getName () + ") found nothing");

            }

        }

        int size1, size2;

        //interface query

        size1 = lookup.lookupAll(java.rmi.Remote.class).size();

        size2 = countInstances(types, java.rmi.Remote.class);

        if (size1 != size2) fail("Lookup with interface failed: " + size1 + " != " + size2);

        // superclass query

        size1 = lookup.lookupAll(A.class).size();

        size2 = countInstances(types, A.class);

        if (size1 != size2) fail("Lookup with superclass failed: " + size1 + " != " + size2);

    }

    /** Test interface inheritance.

     */

    public void testInterfaceInheritance() {

        TestInterfaceInheritanceA[] types = {

            new TestInterfaceInheritanceB() {},

            new TestInterfaceInheritanceBB() {},

            new TestInterfaceInheritanceC() {},

            new TestInterfaceInheritanceD() {}

        };

        for (int i = 0; i < types.length; i++) {

            ic.add(types[i]);

            if (lookup.lookup(types[i].getClass()) == null) {

                // should find an instance

                fail("Lookup (" + types[i].getClass().getName () + ") found nothing");

            }

        }

        int size1, size2;

        //interface query

        LL l = new LL ();

        Lookup.Result<?> res = lookup.lookupResult(java.rmi.Remote.class);

        l.source = res;

        size1 = res.allInstances().size();

        size2 = countInstances(types, java.rmi.Remote.class);

        if (size1 != size2) fail("Lookup with interface failed: " + size1 + " != " + size2);

        // superclass query

        size1 = lookup.lookupAll(TestInterfaceInheritanceA.class).size();

        size2 = countInstances(types, TestInterfaceInheritanceA.class);

        if (size1 != size2) fail("Lookup with superclass failed: " + size1 + " != " + size2);

        res.addLookupListener (l);

        ic.remove (types[0]);

        if (l.getCount () != 1) {

            fail ("No notification that a Remote is removed");

        }

    }

    /** Checks whether the AbstractLookup is guarded against modifications

     * while doing some kind of modification.

     */

    public void testModificationArePreventedWhenDoingModifications () throws Exception {

        BrokenPair broken = new BrokenPair (true, false);

        ic.addPair (broken);

        Lookup.Template<BrokenPair> templ = new Lookup.Template<BrokenPair>(BrokenPair.class);

        Lookup.Item<BrokenPair> item = lookup.lookupItem (templ);

        assertEquals ("Broken is found", broken, item);

    }

    public void testModificationArePreventedWhenDoingModificationsResult () throws Exception {

        BrokenPair broken = new BrokenPair (false, true);

        ic.addPair (broken);

        Lookup.Template<BrokenPair> templ = new Lookup.Template<BrokenPair>(BrokenPair.class);

        Collection<? extends BrokenPair> c = lookup.lookup (templ).allInstances();

        assertEquals ("One item", 1, c.size ());

        assertEquals ("Broken is found again", broken, c.iterator().next ());

    }

    public void testModificationArePreventedWhenDoingModificationsItemAndResult () throws Exception {

        BrokenPair broken = new BrokenPair (false, true);

        ic.addPair (broken);

        Lookup.Template<BrokenPair> templ = new Lookup.Template<BrokenPair>(BrokenPair.class);

        Lookup.Item<BrokenPair> item = lookup.lookupItem (templ);

        assertEquals ("Broken is found", broken, item);

        Collection<? extends BrokenPair> c = lookup.lookup(templ).allInstances();

        assertEquals ("One item", 1, c.size ());

        assertEquals ("Broken is found again", broken, c.iterator().next ());

    }

    public void testModificationArePreventedWhenDoingModificationsResultAndItem () throws Exception {

        BrokenPair broken = new BrokenPair (false, true);

        ic.addPair (broken);

        Lookup.Template<BrokenPair> templ = new Lookup.Template<BrokenPair>(BrokenPair.class);

        Collection<? extends BrokenPair> c = lookup.lookup(templ).allInstances();

        assertEquals ("One item", 1, c.size ());

        assertEquals ("Broken is found again", broken, c.iterator().next ());

        Object item = lookup.lookupItem (templ);

        assertEquals ("Broken is found", broken, item);

    }

    public void testAddALotOfPairsIntoTheLookupOneByOne () throws Exception {

        Lookup.Result<Integer> res = lookup.lookupResult(Integer.class);

        for (int i = 0; i < 1000; i++) {

            ic.add(i);

        }

        assertEquals (

            "there is the right count", 

            1000, 

            res.allItems().size ()

        );

    }

    public void testAddALotOfPairsIntoTheLookup () throws Exception {

        List<Integer> arr = new ArrayList<Integer>();

        for (int i = 0; i < 1000; i++) {

            arr.add(i);

        }

        ic.set (arr, null);

        assertEquals (

            "there is the right count", 

            1000, 

            lookup.lookupResult(Integer.class).allItems().size()

        );

    }

    public void testDoubleAddIssue35274 () throws Exception {

        class P extends AbstractLookup.Pair<Object> {

            protected boolean creatorOf(Object obj) { return false; }

            public String getDisplayName() { return ""; }

            public String getId() { return ""; }

            public Object getInstance() { return null; }

            public Class<?> getType() { return Object.class; }

            protected boolean instanceOf(Class<?> c) { return c.isAssignableFrom(getType ()); }

            public @Override int hashCode() {return getClass().hashCode();}

            public @Override boolean equals(Object obj) {return getClass() == obj.getClass();}

        }

        P p = new P ();

        ic.addPair (p);

        ic.addPair (p);

        Lookup.Result<Object> result = lookup.lookupResult(Object.class);

        Collection res = result.allItems ();

        assertEquals ("One item there", 1, res.size ());

        assertTrue ("It is the p", p == res.iterator ().next ());

        P p2 = new P ();

        ic.addPair (p2);

        Reference<?> ref = new WeakReference<Object>(result);

        result = null;

        assertGC ("The result can disappear", ref);

        impl.clearCaches ();

        result = lookup.lookupResult(Object.class);

        res = result.allItems ();

        assertEquals ("One item is still there", 1, res.size ());

        assertTrue ("But the p2 replaced p", p2 == res.iterator ().next ());

    }

    /** Test for proper serialization.

     */

    public void testSerializationSupport () throws Exception {

        doSerializationSupport (1);

    }