// Test EventHandler.check14().

// Written by Jerry Quinn <jlquinn@optonline.net>

// This file is part of Mauve.

// Mauve is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.

// Mauve is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Mauve; see the file COPYING.  If not, write to
// the Free Software Foundation, 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.

// Tags: JDK1.4

// Test features added by JDK 1.4

package gnu.testlet.java.beans.EventHandler;

import gnu.testlet.Testlet;
import gnu.testlet.TestHarness;
import java.beans.EventHandler;
import java.lang.reflect.Method;

/**
 * <p>Basic tests for the <code>EventHandler</code></p>
 */
public class check14 implements Testlet
{
  // Inner classes because compilation complains it can't find the files
  // otherwise
  public class Target
  {
    public boolean flag;
    public String str;

    public Target() { flag = false; str = null; }
    public void reset() { flag = false; str = null; }

    // Test that null eventPropertyName activates this
    public void action1() { flag = true; }
	
    // Test that moving whole objects works
    public void action(Event e) { str =  e.getD(); flag = e.isB(); }
    // To test that wrapper handling works
    public void setAction(boolean b) { flag = b; }
    // To test that basic properties work
    public void setAction(String s) { str = s; }
	// To test event forwarding.
	public void setEventProperty(Event e) { str =  e.getD(); flag = e.isB(); }
  }

  public class Event
  {
    public Object getA() { return this; }
    public boolean isB() { return true; }
    public Object getC() { return this; }
    public String getD() { return "yes"; }
  }

  public interface Listener
  {
    public void listen1(check14.Event x);
    public void listen2(check14.Event x);
  }
  
  /* A Listener interface without arguments in the methods. */
  public interface Listener2
  {
	  public void listen1();
	  public void listen2();
  }

  public static int x = 0;
  
  /* A variable that has to be set by calling itself. */
  public boolean called;

  public void test (TestHarness harness)
  {
    Target target = new Target();
    Event ev = new Event();

    // Basic event handler value tests
    EventHandler eh = new EventHandler(target, "action", "a.c.b", "listen1");

	// Note: Referential equality works because all String instances where available at compilation time
    harness.check(eh.getAction() == "action", "Check basic settings");
    harness.check(eh.getEventPropertyName() == "a.c.b");
    harness.check(eh.getListenerMethodName() == "listen1");
    harness.check(eh.getTarget() == target);

    // Simple invoke test
    Method listen1 = null;
    Method listen2 = null;
    try
      {
	listen1 = Listener.class.getMethod("listen1",
					   new Class[] {Event.class});
	listen2 = Listener.class.getMethod("listen2",
					   new Class[] {Event.class});
      }
    catch (Exception e)
      {
	harness.fail("No listener methods - test is broken");
      }
    harness.check(target.flag == false, "Test invoke");

    try
      {
	eh.invoke(null, listen1, new Object[] {ev});
      }
    catch (Exception e)
      {
	harness.fail("Invoke listen1 failed " + e.toString());
      }
    harness.check(target.flag == true, "Invoke listen1 test");
    target.reset();

    try
      {
	eh.invoke(null, listen2, new Object[] {ev});
      }
    catch (Exception e)
      {
	harness.fail("Invoke listen2 failed " + e.toString());
      }
    harness.check(target.flag == false, "Invoke listen2 test");
    target.reset();

    // Static create tests
    Listener o1 = (Listener) EventHandler.create(Listener.class,
						 target, "action", "");
	try 
	  {
    o1.listen1(ev);
	  }
	catch(Exception e)
      {
		harness.fail("Invoke listen1 failed " + e.toString());
	  }
    harness.check(target.flag == true, "Test null event property");
    target.reset();

	try 
	  {
    o1.listen2(ev);
	  }
	catch(Exception e)
      {
		harness.fail("Invoke listen1 failed " + e.toString());
	  }
    harness.check(target.flag == true);
    harness.check(target.str == "yes");
    target.reset();
	
	/* Listener methods may have no arguments, too. This tests whether these methods
	 * are properly implemented when calling the static create methods of EventHandler. 
	 */
	Listener2 l2 = (Listener2) EventHandler.create(Listener2.class, target, "action1");
	l2.listen1();
	harness.check(target.flag, true, "no argument listener method");
	target.reset();
	
	l2.listen2();
	harness.check(target.flag, true);
	target.reset();

    Listener o2 = (Listener) EventHandler.create(Listener.class,
						 target, "action1");
    o2.listen1(ev);
    harness.check(target.flag == true, "Test action with no parameter");
    harness.check(target.str == null);
    target.reset();

    o2.listen2(ev);
    harness.check(target.flag == true);
    harness.check(target.str == null);
    target.reset();
	

    Listener o3 = (Listener) EventHandler.create(Listener.class, target,
					       "action", "a.c.d");
    o3.listen1(ev);
    harness.check(target.flag == false, "Test null listener");
    harness.check(target.str == "yes");
    target.reset();

    o3.listen2(ev);
    harness.check(target.flag == false, "Test null listener");
    harness.check(target.str == "yes");
    target.reset();


    Listener o4 = (Listener) EventHandler.create(Listener.class, target,
					       "action", "a.c.d", "listen2");
    o4.listen1(ev);
    harness.check(target.flag == false, "Test full, ignore listen1");
    harness.check(target.str == null);
    target.reset();

    o4.listen2(ev);
    harness.check(target.flag == false, "Test full, invoke listen2");
    harness.check(target.str == "yes");
    target.reset();

    // Make sure created objects actually implement Listener, not just the
    // method.
    Object o5 = EventHandler.create(Listener.class, target, "action");
    Class ifs[] = o5.getClass().getInterfaces();
    boolean found = false;
    for (int i=0; i < ifs.length; i++)
      if (ifs[i] == Listener.class)
	found = true;
    
    harness.check(found == true, "Proxy implements Listener");
	
  }

  public void targetMethod() {
	  called = true;
  }
  
}