/*

  * 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.Serializable;

 import java.util.*;

 import org.netbeans.junit.*;

 import org.openide.util.Lookup;

 import org.openide.util.LookupEvent;

 import org.openide.util.LookupListener;

 /** Runs all NbLookupTest tests on ProxyLookup and adds few additional.

  */

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

 public class LookupsProxyTest extends AbstractLookupBaseHid

 implements AbstractLookupBaseHid.Impl {

     public LookupsProxyTest(java.lang.String testName) {

         super(testName, null);

     }

     public static void main(java.lang.String[] args) {

         junit.textui.TestRunner.run(new NbTestSuite (LookupsProxyTest.class));

     }

     /** 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 (final Lookup lookup) {

         return org.openide.util.lookup.Lookups.proxy (

             new Lookup.Provider () {

                 public Lookup getLookup () {

                     return lookup;

                 }

             }

         );

     }

     public Lookup createInstancesLookup (InstanceContent ic) {

         return new AbstractLookup (ic);

     }

     public void clearCaches () {

     }    

     /** Check whether setLookups method does not fire when there is no

      * change in the lookups.

      */

     public void testProxyListener () {

         Changer ch = new Changer (Lookup.EMPTY);

         Lookup lookup = Lookups.proxy(ch);

         Lookup.Result res = lookup.lookup (new Lookup.Template (Object.class));

         LL ll = new LL ();

         res.addLookupListener (ll);

         Collection allRes = res.allInstances ();

         ch.setLookup (new AbstractLookup (new InstanceContent ())); // another empty lookup

         lookup.lookup (Object.class); // does the refresh

         assertEquals("Replacing an empty by empty does not generate an event", 0, ll.getCount());

         InstanceContent content = new InstanceContent ();

         AbstractLookup del = new AbstractLookup (content);

         content.add (this);

         ch.setLookup (del);

         lookup.lookup (Object.class);

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

             fail ("Changing lookups with different content generates an event");

         }

         ch.setLookup (del);

         lookup.lookup (Object.class);

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

            fail ("Not changing the lookups does not generate any event");

         }

     }

     public void testListeningAndQueryingByTwoListenersInstancesSetLookups() {

         doListeningAndQueryingByTwoListenersSetLookups(0, 1, false);

     }

     public void testListeningAndQueryingByTwoListenersClassesSetLookups() {

         doListeningAndQueryingByTwoListenersSetLookups(1, 1, false);        

     }

     public void testListeningAndQueryingByTwoListenersItemsSetLookups() {

         doListeningAndQueryingByTwoListenersSetLookups(2, 1, false);

     }

     public void testListeningAndQueryingByTwoListenersInstancesSetLookups2() {

         doListeningAndQueryingByTwoListenersSetLookups(0, 2, false);

     }

     public void testListeningAndQueryingByTwoListenersClassesSetLookups2() {

         doListeningAndQueryingByTwoListenersSetLookups(1, 2, false);        

     }

     public void testListeningAndQueryingByTwoListenersItemsSetLookups2() {

         doListeningAndQueryingByTwoListenersSetLookups(2, 2, false);

     }

     public void testListeningAndQueryingByTwoListenersInstancesSetLookupsWithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(0, 1, true);

     }

     public void testListeningAndQueryingByTwoListenersClassesSetLookupsWithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(1, 1, true);        

     }

     public void testListeningAndQueryingByTwoListenersItemsSetLookupsWithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(2, 1, true);

     }

     public void testListeningAndQueryingByTwoListenersInstancesSetLookups2WithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(0, 2, true);

     }

     public void testListeningAndQueryingByTwoListenersClassesSetLookups2WithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(1, 2, true);        

     }

     public void testListeningAndQueryingByTwoListenersItemsSetLookups2WithProxy() {

         doListeningAndQueryingByTwoListenersSetLookups(2, 2, true);

     }

     /* XXX: these are pretty slow, seems there is a performance problem 2^22

     public void testListeningAndQueryingByTwoListenersInstancesSetLookups22() {

         doListeningAndQueryingByTwoListenersSetLookups(0, 22);

     }

     public void testListeningAndQueryingByTwoListenersClassesSetLookups22() {

         doListeningAndQueryingByTwoListenersSetLookups(1, 22);        

     }

     public void testListeningAndQueryingByTwoListenersItemsSetLookups22() {

         doListeningAndQueryingByTwoListenersSetLookups(2, 22);

     }

      */

     private void doListeningAndQueryingByTwoListenersSetLookups(final int type, int depth, boolean cacheOnTop) {

         Changer orig = new Changer(Lookup.EMPTY);

         Lookup on = Lookups.proxy(orig);

         Lookup first = on;

         while (--depth > 0) {

             Changer next = new Changer(on);

             on = Lookups.proxy(next);

         }

         final Lookup lookup = cacheOnTop ? new ProxyLookup(new Lookup[] { on }) : on;

         class L implements LookupListener {

             Lookup.Result integer = lookup.lookup(new Lookup.Template(Integer.class));

             Lookup.Result number = lookup.lookup(new Lookup.Template(Number.class));

             Lookup.Result serial = lookup.lookup(new Lookup.Template(Serializable.class));

             {

                 integer.addLookupListener(this);

                 number.addLookupListener(this);

                 serial.addLookupListener(this);

             }

             int round;

             public void resultChanged(LookupEvent ev) {

                 Collection c1 = get(type, integer);

                 Collection c2 = get(type, number);

                 Collection c3 = get(type, serial);

                 assertEquals("round " + round + " c1 vs. c2", c1, c2);

                 assertEquals("round " + round + " c1 vs. c3", c1, c3);

                 assertEquals("round " + round + " c2 vs. c3", c2, c3);

                 round++;

             }            

             private Collection get(int type, Lookup.Result res) {

                 Collection c;

                 switch(type) {

                     case 0: c = res.allInstances(); break;

                     case 1: c = res.allClasses(); break;

                     case 2: c = res.allItems(); break;

                     default: c = null; fail("Type: " + type); break;

                 }

                 assertNotNull(c);

                 return new ArrayList(c);

             }

         }

         L listener = new L();

         listener.resultChanged(null);

         ArrayList arr = new ArrayList();

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

             arr.add(new Integer(i));

             orig.lookup = Lookups.fixed(arr.toArray());

             // do the refresh

             first.lookup((Class)null);

         }

         assertEquals("3x100+1 checks", 301, listener.round);

     }

     public void testRefreshWithoutAllInstances103300 () {

         Changer ch = new Changer (Lookup.EMPTY);

         Lookup lookup = Lookups.proxy(ch);

         ch.setLookup (new AbstractLookup (new InstanceContent ())); // another empty lookup

         assertNull("Nothing there", lookup.lookup (Object.class)); // does the refresh

         InstanceContent content = new InstanceContent ();

         AbstractLookup del = new AbstractLookup (content);

         content.add (this);

         ch.setLookup (del);

         assertEquals("Can see me", this, lookup.lookup (Object.class));

         ch.setLookup (del);

         assertEquals("Still can see me", this, lookup.lookup (Object.class));

         assertEquals("I am visible", this, lookup.lookup(LookupsProxyTest.class));

     }

     private static final class Changer implements Lookup.Provider {

         private Lookup lookup;

         public Changer (Lookup lookup) {

             setLookup (lookup);

         }

         public void setLookup (Lookup lookup) {

             this.lookup = lookup;

         }

         public Lookup getLookup() {

             return lookup;

         }

     }

 }