if (warnedAsynchronousActions.add(getClass())) {

            ErrorManager.getDefault().log(ErrorManager.WARNING, "Warning - " + getClass().getName() + " should override CallableSystemAction.asynchronous() to return false");

        }

/*

 *                 Sun Public License Notice

 *

 * The contents of this file are subject to the Sun Public License

 * Version 1.0 (the "License"). You may not use this file except in

 * compliance with the License. A copy of the License is available at

 * http://www.sun.com/

 *

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

 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun

 * Microsystems, Inc. All Rights Reserved.

 */

package org.openide.util.actions;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.image.BufferedImage;

import java.awt.image.ImageObserver;

import java.awt.image.PixelGrabber;

import javax.swing.Icon;

import javax.swing.JButton;

import org.netbeans.junit.*;

import junit.textui.TestRunner;

import org.openide.util.HelpCtx;

import org.openide.util.lookup.AbstractLookup;

/** Test general aspects of system actions.

 * Currently, just the icon.

 * @author Jesse Glick

 */

public class AsynchronousTest extends NbTestCase {

    public AsynchronousTest (String name) {

        super(name);

    }

    public static void main(String[] args) {

        System.setProperty("org.openide.util.Lookup", Lkp.class.getName ());

        TestRunner.run(new NbTestSuite(AsynchronousTest.class));

    }

    protected void setUp () {

        ErrManager.messages.delete (0, ErrManager.messages.length ());

    }

    public void testExecutionOfActionsThatDoesNotOverrideAsynchronousIsAsynchronousButWarningIsPrinted () throws Exception {

        DoesNotOverride action = (DoesNotOverride)DoesNotOverride.get (DoesNotOverride.class);

        synchronized (action) {

            action.actionPerformed (new ActionEvent(this, 0, ""));

            Thread.sleep (500);

            assertFalse ("Not yet finished", action.finished);

            action.wait ();

            assertTrue ("The asynchronous action is finished", action.finished);

        }

        if (ErrManager.messages.toString ().indexOf (DoesNotOverride.class.getName () + " should override") < 0) {

            fail ("There should be warning about not overriding asynchronous: " + ErrManager.messages);

        }

    }

    public void testExecutionCanBeAsynchronous () throws Exception {

        DoesOverrideAndReturnsTrue action = (DoesOverrideAndReturnsTrue)DoesOverrideAndReturnsTrue.get (DoesOverrideAndReturnsTrue.class);

        synchronized (action) {

            action.actionPerformed (new ActionEvent(this, 0, ""));

            Thread.sleep (500);

            assertFalse ("Not yet finished", action.finished);

            action.wait ();

            assertTrue ("The asynchronous action is finished", action.finished);

        }

        if (ErrManager.messages.toString ().indexOf (DoesOverrideAndReturnsTrue.class.getName ()) >= 0) {

            fail ("No warning about the class: " + ErrManager.messages);

        }

    }

    public void testExecutionCanBeSynchronous () throws Exception {

        DoesOverrideAndReturnsFalse action = (DoesOverrideAndReturnsFalse)DoesOverrideAndReturnsFalse.get (DoesOverrideAndReturnsFalse.class);

        synchronized (action) {

            action.actionPerformed (new ActionEvent(this, 0, ""));

            assertTrue ("The synchronous action is finished immediatelly", action.finished);

        }

        if (ErrManager.messages.toString ().indexOf (DoesOverrideAndReturnsTrue.class.getName ()) >= 0) {

            fail ("No warning about the class: " + ErrManager.messages);

        }

    }

    public static class DoesNotOverride extends CallableSystemAction {

        boolean finished;

        public HelpCtx getHelpCtx () {

            return HelpCtx.DEFAULT_HELP;

        }

        public String getName () {

            return "Should warn action";

        }

        public synchronized void performAction () {

            notifyAll ();

            finished = true;

        }

    }

    public static class DoesOverrideAndReturnsTrue extends DoesNotOverride {

        public boolean asynchronous () {

            return true;

        }

    }

    public static final class DoesOverrideAndReturnsFalse extends DoesOverrideAndReturnsTrue {

        public boolean asynchronous () {

            return false;

        }

    }

    public static final class Lkp extends AbstractLookup {

        public Lkp () {

            this (new org.openide.util.lookup.InstanceContent ());

        }

        private Lkp (org.openide.util.lookup.InstanceContent ic) {

            super (ic);

            ic.add (new ErrManager ());

        }

    }

    private static final class ErrManager extends org.openide.ErrorManager {

        public static final StringBuffer messages = new StringBuffer ();

        public Throwable annotate (Throwable t, int severity, String message, String localizedMessage, Throwable stackTrace, java.util.Date date) {

            return t;

        }

        public Throwable attachAnnotations (Throwable t, org.openide.ErrorManager.Annotation[] arr) {

            return t;

        }

        public org.openide.ErrorManager.Annotation[] findAnnotations (Throwable t) {

            return null;

        }

        public org.openide.ErrorManager getInstance (String name) {

            return this;

        }

        public void log (int severity, String s) {

            messages.append (s);

            messages.append ('\n');

        }

        public void notify (int severity, Throwable t) {

        }

    } 

}