/*

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

 *

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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-2008 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.netbeans.modules.gsf.testrunner;

//import org.netbeans.modules.gsf.testrunner.CommonSettings;

//import org.netbeans.modules.gsf.testrunner.ClassNameTextField;

import java.awt.*;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.List;

import java.util.*;

import javax.swing.*;

import javax.swing.border.Border;

import javax.swing.border.CompoundBorder;

import javax.swing.border.TitledBorder;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.plaf.UIResource;

import javax.swing.text.JTextComponent;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.SourceGroup;

import org.netbeans.api.project.SourceGroupModifier;

import org.netbeans.modules.gsf.testrunner.ClassNameTextField;

//import org.netbeans.modules.gsf.testrunner.CommonSettings;

//import org.netbeans.modules.gsf.testrunner.GuiUtils;

import org.netbeans.modules.gsf.testrunner.MessageStack;

import org.netbeans.modules.gsf.testrunner.api.CommonSettings;

import org.netbeans.modules.gsf.testrunner.api.CommonTestUtil;

import org.netbeans.modules.gsf.testrunner.api.GuiUtils;

import org.netbeans.modules.gsf.testrunner.api.SelfResizingPanel;

import org.openide.DialogDescriptor;

import org.openide.DialogDisplayer;

import org.openide.awt.Mnemonics;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.loaders.DataFolder;

import org.openide.loaders.DataObject;

import org.openide.nodes.Node;

import org.openide.util.HelpCtx;

import org.openide.util.Lookup;

import org.openide.util.NbBundle;

/**

 *

 * @author  vstejskal

 * @author  Marian Petras

 */

@SuppressWarnings("serial")

public class CommonTestsCfgOfCreate extends SelfResizingPanel implements ChangeListener {

    /** suffix of test classes */

    private static final String TEST_CLASS_SUFFIX = "Test";             //NOI18N

    /**

     * nodes selected when the Create Tests action was invoked

     */

    private  Node[] nodes;

    /** whether the tests will be created for multiple classes */

    private  boolean multipleClasses;

    /** whether a single package/folder is selected */

    private boolean singlePackage;

    /** whether a single class is selected */

    private boolean singleClass;

    /** test class name specified in the form (or <code>null</code>) */

    private String testClassName;

    /** registered change listeners */

    private List<ChangeListener> changeListeners;

    /** */

    private String initialMessage;

    /** */

    private List<String> testingFrameworks;

//    public static final String JUNIT_TEST_FRAMEWORK = "JUnit";             //NOI18N

//    public static final String TESTNG_TEST_FRAMEWORK = "TestNG";             //NOI18N

    private String selectedTestingFramework = null;

    /**

     * is at least one target folder/source group available?

     *

     * @see  #isAcceptable()

     */

    private boolean hasTargetFolders = false;

    /**

     * is the entered class name non-empty and valid?

     *

     * @see  #isAcceptable()

     */

    private boolean classNameValid;

    /**

     * is the current form contents acceptable?

     *

     * @see  #isAcceptable()

     */

    private boolean isAcceptable;

    /** layer index for a message about an empty set of target folders */

    private static final int MSG_TYPE_NO_TARGET_FOLDERS = 0;

    /** layer index for a message about invalid class name */

    private static final int MSG_TYPE_CLASSNAME_INVALID = 1;

    /** layer index for a message about non-default class name */

    private static final int MSG_TYPE_CLASSNAME_NOT_DEFAULT = 2;

    /** layer index for a message about modified files */

    private static final int MSG_TYPE_MODIFIED_FILES = 3;

    /** */

    private MessageStack msgStack = new MessageStack(4);

    public CommonTestsCfgOfCreate(Node[] nodes) {

        assert (nodes != null) && (nodes.length != 0);

        this.nodes = nodes;

    }

    /**

     * Creates a configuration panel.

     *

     * @param nodes  nodes selected when the Create Tests action was invoked

     * @param isShowMsgFilesWillBeSaved if {@code true} then a warning message

     *        like "Warning: All modified files will be saved." will be

     *        displayed on the panel, otherwise (i.e. if {@code false}) then

     *        the message won't be displayed.

     */

    public void createCfgPanel(boolean isShowMsgFilesWillBeSaved) {

//        assert (nodes != null) && (nodes.length != 0);

//        this.nodes = nodes;

        multipleClasses = checkMultipleClasses();

        initBundle();

        try {

            initComponents();

            if(isShowMsgFilesWillBeSaved) {

                String msg = bundle.getString("MSG_MODIFIED_FILES"); // NOI18N

                setMessage(msg, MSG_TYPE_MODIFIED_FILES);

            }

            setBorder(BorderFactory.createEmptyBorder(12, 12, 0, 11));

            addAccessibleDescriptions();

            initializeCheckBoxStates();

            fillFormData();

            checkAcceptability();

            setupUserInteraction();

            /*

             * checkAcceptability() must not be called

             *        before initializeCheckBoxStates() and fillFormData()

             * setupUserInteraction must not be called

             *        before initializeCheckBoxStates()

             */

        } finally {

            unlinkBundle();

        }

    }

    private void addAccessibleDescriptions() {

        // window

        this.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.AD"));

        // text-field and combo-box

        if (this.tfClassName != null) {

            this.tfClassName.setToolTipText(

                  bundle.getString("CommonTestsCfgOfCreate.clsName.toolTip"));//NOI18N

            this.tfClassName.getAccessibleContext().setAccessibleName(

                  bundle.getString("CommonTestsCfgOfCreate.clsName.AN"));     //NOI18N

            this.tfClassName.getAccessibleContext().setAccessibleDescription(

                  bundle.getString("CommonTestsCfgOfCreate.clsName.AD"));     //NOI18N

        }

        this.cboxLocation.setToolTipText(

                bundle.getString("CommonTestsCfgOfCreate.location.toolTip")); //NOI18N

        this.cboxLocation.getAccessibleContext().setAccessibleName(

                bundle.getString("CommonTestsCfgOfCreate.location.AN"));      //NOI18N

        this.cboxLocation.getAccessibleContext().setAccessibleDescription(

                bundle.getString("CommonTestsCfgOfCreate.location.AD"));      //NOI18N

        this.cboxLocation.setToolTipText(

                bundle.getString("CommonTestsCfgOfCreate.framework.toolTip")); //NOI18N

        this.cboxLocation.getAccessibleContext().setAccessibleName(

                bundle.getString("CommonTestsCfgOfCreate.framework.AN"));      //NOI18N

        this.cboxLocation.getAccessibleContext().setAccessibleDescription(

                bundle.getString("CommonTestsCfgOfCreate.framework.AD"));      //NOI18N

        // check boxes

        this.chkPublic.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkPublic.toolTip"));

        this.chkPublic.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkPublic.AD"));        

        this.chkProtected.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkProtected.toolTip"));

        this.chkProtected.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkProtected.AD"));        

        this.chkPackage.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkPackage.toolTip"));

        this.chkPackage.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkPackage.AD"));

        this.chkComments.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkComments.toolTip"));        

        this.chkComments.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkComments.AD"));

        this.chkContent.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkContent.toolTip"));

        this.chkContent.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkContent.AD"));

        this.chkJavaDoc.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkJavaDoc.toolTip"));

        this.chkJavaDoc.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkJavaDoc.AD"));

        if (multipleClasses) {

            this.chkExceptions.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkExceptions.toolTip"));

            this.chkExceptions.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkExceptions.AD"));

            this.chkAbstractImpl.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkAbstractImpl.toolTip"));

            this.chkAbstractImpl.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkAbstractImpl.AD"));

            this.chkPackagePrivateClasses.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkPackagePrivateClasses.toolTip"));

            this.chkPackagePrivateClasses.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkPackagePrivateClasses.AD"));

            this.chkGenerateSuites.setToolTipText(bundle.getString("CommonTestsCfgOfCreate.chkGenerateSuites.toolTip"));

            this.chkGenerateSuites.getAccessibleContext().setAccessibleDescription(bundle.getString("CommonTestsCfgOfCreate.chkGenerateSuites.AD"));

        }

    }

    /**

     * Checks whether multiple classes may be selected.

     * It also detects whether exactly one package/folder or exactly one class

     * is selected and sets values of variables {@link #singlePackage}

     * and {@link #singleClass} accordingly.

     *

     * @return  <code>false</code> if there is exactly one node selected

     *          and the node represents a single <code>DataObject</code>,

     *          not a folder or another <code>DataObject</code> container;

     *          <code>true</code> otherwise

     */

    private boolean checkMultipleClasses() {

        if (nodes.length > 1) {

            return true;

        }

        Lookup nodeLookup = nodes[0].getLookup();

        if (nodeLookup.lookup(DataObject.Container.class) != null) {

            singlePackage = nodeLookup.lookup(DataFolder.class)

                            != null;

            return true;

        }

        singleClass = false;

        DataObject dataObj = nodeLookup.lookup(DataObject.class);

        if (dataObj == null) {

            return true;

        }

        singleClass = dataObj.getPrimaryFile().isData();

        return !singleClass;

    }

    /**

     * Displays a configuration dialog and updates JUnit options according

     * to the user's settings.

     *

     * @param  nodes  nodes selected when the Create Test action was invoked

     */

    public boolean configure() {

        // create and display the dialog:

        String title = NbBundle.getMessage(GuiUtils.class,

                                           "CommonTestsCfgOfCreate.Title");   //NOI18N

        ChangeListener changeListener;

        final JButton btnOK = new JButton(

                NbBundle.getMessage(GuiUtils.class, "LBL_OK")); //NOI18N

        btnOK.getAccessibleContext().setAccessibleName(NbBundle.getMessage(GuiUtils.class, "AN_OK"));

        btnOK.getAccessibleContext().setAccessibleDescription(NbBundle.getMessage(GuiUtils.class, "AD_OK"));

        btnOK.setEnabled(isAcceptable());

        addChangeListener(changeListener = new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                btnOK.setEnabled(isAcceptable());

            }

        });

        Object returned = DialogDisplayer.getDefault().notify(

                new DialogDescriptor (

                        this,

                        title,

                        true,                       //modal

                        new Object[] {btnOK, DialogDescriptor.CANCEL_OPTION},

                        btnOK,                      //initial value

                        DialogDescriptor.DEFAULT_ALIGN,

                        new HelpCtx(CommonTestsCfgOfCreate.class),

                        (ActionListener) null

                ));

        removeChangeListener(changeListener);

        if (returned == btnOK) {

            rememberCheckBoxStates();

            testClassName = (tfClassName != null) ? tfClassName.getText() 

                                                  : null;

            return true;

        }

        return false;

    }

    /**

     * Returns whether a test for a single class is to be created.

     *

     * @return  true if there is only one node selected and the node

     *          represents a class

     */

    public boolean isSingleClass() {

        return singleClass;

    }

    public boolean isSinglePackage() {

        return singlePackage;

    }

    /**

     * Returns the class name entered in the text-field.

     *

     * @return  class name entered in the form,

     *          or <code>null</code> if the form did not contain

     *          the field for entering class name

     */

    public String getTestClassName() {

        return testClassName;

    }

    /** resource bundle used during initialization of this panel */

    public ResourceBundle bundle;

    /**

     * Reads JUnit settings and initializes checkboxes accordingly.

     *

     * @see  #rememberCheckBoxStates

     */

    private void initializeCheckBoxStates() {

        final CommonSettings settings = CommonSettings.getDefault();

        chkPublic.setSelected(settings.isMembersPublic());

        chkProtected.setSelected(settings.isMembersProtected());

        chkPackage.setSelected(settings.isMembersPackage());

        chkComments.setSelected(settings.isBodyComments());

        chkContent.setSelected(settings.isBodyContent());

        chkJavaDoc.setSelected(settings.isJavaDoc());        

        if (multipleClasses) {

            chkGenerateSuites.setSelected(settings.isGenerateSuiteClasses());        

            chkPackagePrivateClasses.setSelected(

                    settings.isIncludePackagePrivateClasses());

            chkAbstractImpl.setSelected(settings.isGenerateAbstractImpl());

            chkExceptions.setSelected(settings.isGenerateExceptionClasses());

        }

        chkSetUp.setSelected(settings.isGenerateSetUp());

        chkTearDown.setSelected(settings.isGenerateTearDown());

    }

    /**

     * Stores settings given by checkbox states to JUnit settings.

     *

     * @see  #initializeCheckBoxStatesf

     */

    private void rememberCheckBoxStates() {

        final CommonSettings settings = CommonSettings.getDefault();

        settings.setMembersPublic(chkPublic.isSelected());

        settings.setMembersProtected(chkProtected.isSelected());

        settings.setMembersPackage(chkPackage.isSelected());

        settings.setBodyComments(chkComments.isSelected());

        settings.setBodyContent(chkContent.isSelected());

        settings.setJavaDoc(chkJavaDoc.isSelected());

        if (multipleClasses) {

            settings.setGenerateSuiteClasses(chkGenerateSuites.isSelected());

            settings.setIncludePackagePrivateClasses(

                    chkPackagePrivateClasses.isSelected());

            settings.setGenerateAbstractImpl(chkAbstractImpl.isSelected());

            settings.setGenerateExceptionClasses(chkExceptions.isSelected());

        }

        settings.setGenerateSetUp(chkSetUp.isSelected());

        settings.setGenerateTearDown(chkTearDown.isSelected());

    }

    /**

     * Loads a resource bundle so that it can be used during intialization

     * of this panel.

     *

     * @see  #unlinkBundle

     */

    private void initBundle() {

        bundle = NbBundle.getBundle(GuiUtils.class);

    }

    /**

     * Nulls the resource bundle so that it is not held in memory when it is

     * not used.

     *

     * @see  #initBundle

     */

    private void unlinkBundle() {

        bundle = null;

    }

    /**

     * This method is called from within the constructor to initialize the form.

     */

    private void initComponents() {

        setLayout(new BorderLayout(0, 12));

        add(createNameAndLocationPanel(), BorderLayout.NORTH);

        add(createMessagePanel(), BorderLayout.CENTER);

        add(createCodeGenPanel(), BorderLayout.SOUTH);

    }

    /**

     */

    private void setupUserInteraction() {

        final ItemListener listener = new CheckBoxListener();

        chkPublic.addItemListener(listener);

        chkProtected.addItemListener(listener);

        chkPackage.addItemListener(listener);

    }

    /**

     * Listener object that listens on state changes of some check-boxes.

     */

    private final class CheckBoxListener implements ItemListener {

        public CheckBoxListener () {}

        @Override

        public void itemStateChanged(ItemEvent e) {

            final Object source = e.getSource();

            assert source == chkPublic

                   || source == chkProtected

                   || source == chkPackage;

            checkAcceptability();

        }

    }

//    public String getTestingFramework() {

//        Object selectedTestingFramework = cboxFramework.getSelectedItem();

//        if(selectedTestingFramework == null) {

//            return null;

//        }

//        return selectedTestingFramework.toString().equals(TESTNG_TEST_FRAMEWORK) ? TESTNG_TEST_FRAMEWORK : JUNIT_TEST_FRAMEWORK;

//    }

    private String getTestingFrameworkFolder() {

        Object tf = cboxFramework.getSelectedItem();

        if(tf == null) {

            return "";

        }

        return tf.toString().equals(GuiUtils.TESTNG_TEST_FRAMEWORK) ? "testng." : ""; //NOI18N

    }

    private void fireFrameworkChanged() {

        if (tfClassName != null) {

            DataObject dataObj = nodes[0].getLookup().lookup(DataObject.class);

            FileObject fileObj = dataObj.getPrimaryFile();

            ClassPath cp = ClassPath.getClassPath(fileObj, ClassPath.SOURCE);

            String className = cp.getResourceName(fileObj, '.', false);

            String prefilledName = getTestingFrameworkFolder() + className + TEST_CLASS_SUFFIX;

            tfClassName.setText(prefilledName);

            tfClassName.setDefaultText(prefilledName);

            tfClassName.setCaretPosition(prefilledName.length());

        }

        setSelectedTestingFramework();

    }

    private void setSelectedTestingFramework() {

        Object tf = cboxFramework.getSelectedItem();

        if(tf != null) {

            selectedTestingFramework = tf.toString();

        }

    }

    public String getSelectedTestingFramework() {

        return selectedTestingFramework;

    }

    public void addTestingFrameworks(ArrayList<String> testingFrameworksToAdd) {

        for(String testingFramework : testingFrameworksToAdd) {

            testingFrameworks.add(testingFramework);

        }

        cboxFramework.setModel(new DefaultComboBoxModel(testingFrameworks.toArray()));

        fireFrameworkChanged();

    }

    /**

     */

    private Component createNameAndLocationPanel() {

        JPanel panel = new JPanel();

        final boolean askForClassName = singleClass;

        JLabel lblClassToTest = new JLabel();

        JLabel lblClassName = askForClassName ? new JLabel() : null;

        JLabel lblLocation = new JLabel();

        JLabel lblFramework = new JLabel();

        String classToTestKey = singlePackage

                                ? "LBL_PackageToTest"                   //NOI18N

                                : singleClass

                                  ? "LBL_ClassToTest"                   //NOI18N

                                  : "LBL_MultipleClassesSelected";      //NOI18N

        Mnemonics.setLocalizedText(

                lblClassToTest,

                NbBundle.getMessage(GuiUtils.class, classToTestKey));

        if (askForClassName) {

            Mnemonics.setLocalizedText(

                    lblClassName,

                    NbBundle.getMessage(GuiUtils.class, "LBL_ClassName"));  //NOI18N

        }

        Mnemonics.setLocalizedText(

                lblLocation,

                NbBundle.getMessage(GuiUtils.class, "LBL_Location"));       //NOI18N

        Mnemonics.setLocalizedText(

                lblFramework,

                NbBundle.getMessage(GuiUtils.class, "LBL_Framework"));       //NOI18N

        if (singlePackage || singleClass) {

            lblClassToTestValue = new JLabel();

        }

        if (askForClassName) {

            tfClassName = new ClassNameTextField();

            tfClassName.setChangeListener(this);

        }

        cboxLocation = new JComboBox();

        cboxFramework = new JComboBox();

        testingFrameworks = new ArrayList<String>();

        cboxFramework.setModel(new DefaultComboBoxModel(testingFrameworks.toArray()));

        cboxFramework.addItemListener(new java.awt.event.ItemListener() {

            @Override

            public void itemStateChanged(java.awt.event.ItemEvent evt) {

                fireFrameworkChanged();

            }

        });

        if (askForClassName) {

            lblClassName.setLabelFor(tfClassName);

        }

        lblLocation.setLabelFor(cboxLocation);

        lblFramework.setLabelFor(cboxFramework);

        if (lblClassToTestValue != null) {

            Font labelFont = javax.swing.UIManager.getDefaults()

                             .getFont("TextField.font");                //NOI18N

            if (labelFont != null) {

                lblClassToTestValue.setFont(labelFont);

            }

        }

        panel.setLayout(new GridBagLayout());

        GridBagConstraints gbcLeft = new GridBagConstraints();

        gbcLeft.anchor = GridBagConstraints.WEST;

        gbcLeft.insets.bottom = 12;

        gbcLeft.insets.right = 6;

        GridBagConstraints gbcRight = new GridBagConstraints();

        gbcRight.anchor = GridBagConstraints.WEST;

        gbcRight.insets.bottom = 12;

        gbcRight.weightx = 1.0f;

        gbcRight.fill = GridBagConstraints.BOTH;

        gbcRight.gridwidth = GridBagConstraints.REMAINDER;

        if (lblClassToTestValue != null) {

            panel.add(lblClassToTest,      gbcLeft);

            panel.add(lblClassToTestValue, gbcRight);

        } else {

            panel.add(lblClassToTest,   gbcRight);

        }

        if (askForClassName) {

            panel.add(lblClassName,     gbcLeft);

            panel.add(tfClassName,      gbcRight);

        }

        panel.add(lblLocation,      gbcLeft);

        panel.add(cboxLocation,     gbcRight);

        gbcLeft.insets.bottom = 0;

        gbcRight.insets.bottom = 0;

        panel.add(lblFramework,      gbcLeft);

        panel.add(cboxFramework,     gbcRight);

        return panel;

    }

    /**

     */

    private void checkClassNameValidity() {

        if (tfClassName == null) {

            classNameValid = true;

            return;

        }

        String key = null;

        final int state = tfClassName.getStatus();

        switch (state) {

            case ClassNameTextField.STATUS_EMPTY:

                key = "MSG_ClassnameMustNotBeEmpty";                    //NOI18N

                break;

            case ClassNameTextField.STATUS_INVALID:

                key = "MSG_InvalidClassName";                           //NOI18N

                break;

            case ClassNameTextField.STATUS_VALID_NOT_DEFAULT:

                key = "MSG_ClassNameNotDefault";                        //NOI18N

                break;

            case ClassNameTextField.STATUS_VALID_END_NOT_TEST:

                key = "MSG_ClassNameEndNotTest";                        //NOI18N

                break;

        }

        if (state != ClassNameTextField.STATUS_VALID_NOT_DEFAULT) {

            setMessage(null, MSG_TYPE_CLASSNAME_NOT_DEFAULT);

        }

        setMessage((key != null)

                           ? NbBundle.getMessage(GuiUtils.class, key)

                           : null,

                   MSG_TYPE_CLASSNAME_INVALID);

        classNameValid =

                (state == ClassNameTextField.STATUS_VALID)

                || (state == ClassNameTextField.STATUS_VALID_NOT_DEFAULT);

    }

    /**

     * This method gets called if status of contents of the Class Name

     * text field changes. See <code>STATUS_xxx</code> constants

     * in class <code>ClassNameTextField</code>.

     *

     * @param  e  event describing the state change event

     *            (unused in this method)

     */

    @Override

    public void stateChanged(ChangeEvent e) {

        checkClassNameValidity();

        checkAcceptability();

    }

    /**

     */

    private void checkAcceptability() {

        final boolean wasAcceptable = isAcceptable;

        isAcceptable = hasTargetFolders && classNameValid;

        if (isAcceptable != wasAcceptable) {

            fireStateChange();

        }

    }

    /**

     * Are the values filled in the form acceptable?

     *

     * @see  #addChangeListener

     */

    private boolean isAcceptable() {

        return isAcceptable;

    }

    /**

     * This method is called the first time this panel's children are painted.

     * By default, this method just calls {@link #adjustWindowSize()}.

     *

     * @param  g  <code>Graphics</code> used to paint this panel's children

     */

    @Override

    protected void paintedFirstTime(java.awt.Graphics g) {

        if (initialMessage != null) {

            displayMessage(initialMessage);

            initialMessage = null;

        }

    }

    /**

     * Displays a given message in the message panel and resizes the dialog

     * if necessary. If the message cannot be displayed immediately,

     * because of this panel not displayed (painted) yet, displaying the message

     * is deferred until this panel is painted.

     *

     * @param  message  message to be displayed, or <code>null</code> if

     *                  the currently displayed message (if any) should be

     *                  removed

     */

    private void setMessage(final String message, final int msgType) {

        String msgToDisplay = msgStack.setMessage(msgType, message);

        if (msgToDisplay == null) {

            return;                     //no change

        }

        /* display the message: */

        if (!isPainted()) {

            initialMessage = msgToDisplay;

        } else {

            displayMessage(msgToDisplay);

        }

    }

    /**

     * Displays a given message in the message panel and resizes the dialog

     * if necessary.

     *

     * @param  message  message to be displayed, or <code>null</code> if

     *                  the currently displayed message (if any) should be

     *                  removed

     * @see  #adjustWindowSize()

     */

    private void displayMessage(String message) {

        if (message == null) {

            message = "";                                               //NOI18N

        }

        txtAreaMessage.setText(message);

        adjustWindowSize();

    }

    /**

     */

    private Component createMessagePanel() {

        Color color = UIManager.getColor("nb.errorForeground");         //NOI18N

        if (color == null) {

            color = new Color(89, 79, 191);   //RGB suggested by Bruce in #28466

        }

        txtAreaMessage = GuiUtils.createMultilineLabel("", color);      //NOI18N

        return txtAreaMessage;

    }

    /**

     * Creates a panel containing controls for settings code generation options.

     *

     * @return   created panel

     */

    private Component createCodeGenPanel() {

        /* create the components: */

        String[] chkBoxIDs;

        JCheckBox[] chkBoxes;

        if (multipleClasses) {

            chkBoxIDs = new String[] {

                GuiUtils.CHK_PUBLIC,

                GuiUtils.CHK_PROTECTED,

                GuiUtils.CHK_PACKAGE,

                GuiUtils.CHK_PACKAGE_PRIVATE_CLASSES,

                GuiUtils.CHK_ABSTRACT_CLASSES,

                GuiUtils.CHK_EXCEPTION_CLASSES,

                GuiUtils.CHK_SUITES,

                GuiUtils.CHK_SETUP,

                GuiUtils.CHK_TEARDOWN,

                GuiUtils.CHK_METHOD_BODIES,

                GuiUtils.CHK_JAVADOC,

                GuiUtils.CHK_HINTS

            };

        } else {

            chkBoxIDs = new String[] {

                GuiUtils.CHK_PUBLIC,

                GuiUtils.CHK_PROTECTED,

                GuiUtils.CHK_PACKAGE,

                null, // CHK_PACKAGE_PRIVATE_CLASSES,

                null, // CHK_ABSTRACT_CLASSES,

                null, // CHK_EXCEPTION_CLASSES,

                null, // CHK_SUITES,

                GuiUtils.CHK_SETUP,

                GuiUtils.CHK_TEARDOWN,

                GuiUtils.CHK_METHOD_BODIES,

                GuiUtils.CHK_JAVADOC,

                GuiUtils.CHK_HINTS

            };

        }

        chkBoxes = GuiUtils.createCheckBoxes(chkBoxIDs);

        int i = 0;

        chkPublic           = chkBoxes[i++];

        chkProtected        = chkBoxes[i++];

        chkPackage          = chkBoxes[i++];

        chkPackagePrivateClasses = chkBoxes[i++];       //may be null

        chkAbstractImpl     = chkBoxes[i++];            //may be null

        chkExceptions       = chkBoxes[i++];            //may be null

        chkGenerateSuites   = chkBoxes[i++];            //may be null

        chkSetUp            = chkBoxes[i++];

        chkTearDown         = chkBoxes[i++];        

        chkContent          = chkBoxes[i++];

        chkJavaDoc          = chkBoxes[i++];

        chkComments         = chkBoxes[i++];

        /* create groups of checkboxes: */

        JComponent methodAccessLevels = GuiUtils.createChkBoxGroup(

                bundle.getString("CommonTestsCfgOfCreate.groupAccessLevels"), //NOI18N

                new JCheckBox[] {chkPublic, chkProtected, chkPackage});

        JComponent classTypes = null;

        JComponent optionalClasses = null;

        if (multipleClasses) {

            classTypes = GuiUtils.createChkBoxGroup(

                bundle.getString("CommonTestsCfgOfCreate.groupClassTypes"),   //NOI18N

                new JCheckBox[] {chkPackagePrivateClasses,

                                 chkAbstractImpl, chkExceptions});

            optionalClasses = GuiUtils.createChkBoxGroup(

                bundle.getString("CommonTestsCfgOfCreate.groupOptClasses"),   //NOI18N

                new JCheckBox[] {chkGenerateSuites});

        }

        JComponent optionalCode = GuiUtils.createChkBoxGroup(

                bundle.getString("CommonTestsCfgOfCreate.groupOptCode"),      //NOI18N

                new JCheckBox[] {chkSetUp, chkTearDown, chkContent});

        JComponent optionalComments = GuiUtils.createChkBoxGroup(

                bundle.getString("CommonTestsCfgOfCreate.groupOptComments"),  //NOI18N

                new JCheckBox[] {chkJavaDoc, chkComments});

        /* create the left column of options: */

        Box leftColumn = Box.createVerticalBox();

        leftColumn.add(methodAccessLevels);

        if (multipleClasses) {

            leftColumn.add(Box.createVerticalStrut(11));

            leftColumn.add(classTypes);

        } else {

            /*

             * This strut ensures that width of the left column is not limited.

             * If it was limited, the rigth column would not move when the

             * dialog is horizontally resized.

             */

            leftColumn.add(Box.createVerticalStrut(0));

        }

        leftColumn.add(Box.createVerticalGlue());

        /* create the right column of options: */

        Box rightColumn = Box.createVerticalBox();

        if (multipleClasses) {

            rightColumn.add(optionalClasses);

            rightColumn.add(Box.createVerticalStrut(11));

        }

        rightColumn.add(optionalCode);

        rightColumn.add(Box.createVerticalStrut(11));

        rightColumn.add(optionalComments);

        rightColumn.add(Box.createVerticalGlue());

        /* compose the final panel: */

        //JPanel jpCodeGen = new SizeRestrictedPanel(false, true);

        JPanel jpCodeGen = new JPanel();

        jpCodeGen.setLayout(new BoxLayout(jpCodeGen, BoxLayout.X_AXIS));

        jpCodeGen.add(leftColumn);

        jpCodeGen.add(Box.createHorizontalStrut(24));

        jpCodeGen.add(rightColumn);

        /* decorate the panel: */

        addTitledBorder(jpCodeGen,

                  new Insets(12, 12, 11, 12),

                  bundle.getString("CommonTestsCfgOfCreate.jpCodeGen.title"));//NOI18N

        /* tune the layout: */

        methodAccessLevels.setAlignmentX(0.0f);

        if (multipleClasses) {

            classTypes.setAlignmentX(0.0f);

            optionalClasses.setAlignmentX(0.0f);

        }

        optionalCode.setAlignmentX(0.0f);

        optionalComments.setAlignmentX(0.0f);

        return jpCodeGen;

    }

    /**

     * Adds a border and a title around a given component.

     * If the component already has some border, it is overridden (not kept).

     *

     * @param  component  component the border and title should be added to

     * @param  insets  insets between the component and the titled border

     * @param  title  text of the title

     */

    private static void addTitledBorder(JComponent component,

                                        Insets insets,

                                        String title) {

        Border insideBorder = BorderFactory.createEmptyBorder(

                insets.top, insets.left, insets.bottom, insets.right);

        Border outsideBorder = new TitledBorder(

                BorderFactory.createEtchedBorder(), title);

        component.setBorder(new CompoundBorder(outsideBorder, insideBorder));

    }

    /**

     */

    public FileObject getTargetFolder() {

        Object selectedLocation = cboxLocation.getSelectedItem();

        if (selectedLocation == null) {

            return null;

        }

        if (selectedLocation instanceof SourceGroup) {

            return ((SourceGroup) selectedLocation).getRootFolder();

        }

        assert selectedLocation instanceof FileObject;      //root folder

        return (FileObject) selectedLocation;

    }

    /**

     * Initializes form in the Test Settings panel of the dialog.

     */

    private void fillFormData() {

        final DataObject dataObj = nodes[0].getLookup().lookup(DataObject.class);

        final FileObject fileObj = dataObj.getPrimaryFile();

        if (singleClass) {

            assert nodes.length == 1;

            ClassPath cp = ClassPath.getClassPath(fileObj, ClassPath.SOURCE);

            String className = cp.getResourceName(fileObj, '.', false);

            lblClassToTestValue.setText(className);

            if (tfClassName != null) {

                String prefilledName = getTestingFrameworkFolder() + className + TEST_CLASS_SUFFIX;

                tfClassName.setText(prefilledName);

                tfClassName.setDefaultText(prefilledName);

                tfClassName.setCaretPosition(prefilledName.length());

            }

        } else if (singlePackage) {

            assert nodes.length == 1;

            ClassPath cp = ClassPath.getClassPath(fileObj, ClassPath.SOURCE);

            String packageName = cp.getResourceName(fileObj, '.', true);

            if (packageName.length() == 0) {

                packageName = NbBundle.getMessage(

                        GuiUtils.class,

                        "DefaultPackageName");                          //NOI18N

            }

            lblClassToTestValue.setText(packageName);

        } else {

            //PENDING

        }

        setupLocationChooser(fileObj);

        checkClassNameValidity();

    }

    /**

     */

    private void setupLocationChooser(FileObject refFileObject) {

        Object[] targetFolders = CommonTestUtil.getTestTargets(refFileObject);

        if (targetFolders.length == 0) {

            Project owner = FileOwnerQuery.getOwner(refFileObject);

            if (owner != null) {

                if (SourceGroupModifier.createSourceGroup(owner, JavaProjectConstants.SOURCES_TYPE_JAVA, JavaProjectConstants.SOURCES_HINT_TEST) != null) {

                    targetFolders = CommonTestUtil.getTestTargets(refFileObject);

                }

            }

        }

        if (targetFolders.length != 0) {

            hasTargetFolders = true;

            cboxLocation.setModel(new DefaultComboBoxModel(targetFolders));

            cboxLocation.setRenderer(new LocationChooserRenderer());

        } else {

            hasTargetFolders = false;

            //PENDING - message text:

            String msgNoTargetsFound = NbBundle.getMessage(

                                        getClass(),

                                        refFileObject.isFolder()

                                                ? "MSG_NoTestTarget_Fo" //NOI18N

                                                : "MSG_NoTestTarget_Fi",//NOI18N

                                        refFileObject.getNameExt());

            setMessage(msgNoTargetsFound, MSG_TYPE_NO_TARGET_FOLDERS);

            disableComponents();

        }

    }

    /**

     * Renderer which specially handles values of type

     * <code>SourceGroup</code> and <code>FileObject</code>.

     * It displays display names of these objects, instead of their default

     * string representation (<code>toString()</code>).

     *

     * @see  SourceGroup#getDisplayName()

     * @see  FileUtil#getFileDisplayName(FileObject)

     */

    private final class LocationChooserRenderer extends JLabel implements ListCellRenderer, UIResource {

        public LocationChooserRenderer () {

            setOpaque(true);

        }

        @Override

        public Component getListCellRendererComponent(

                JList list,

                Object value,

                int index,

                boolean isSelected,

                boolean cellHasFocus) {

            // #93658: GTK needs name to render cell renderer "natively"

            setName("ComboBox.listRenderer"); // NOI18N

            String text = value instanceof SourceGroup

                        ? ((SourceGroup) value).getDisplayName()

                        : value instanceof FileObject

                              ?  FileUtil.getFileDisplayName((FileObject) value)

                              : value.toString();

            setText(text);

            if ( isSelected ) {

                setBackground(list.getSelectionBackground());

                setForeground(list.getSelectionForeground());             

            }

            else {

                setBackground(list.getBackground());

                setForeground(list.getForeground());

            }

            return this;

        }

        // #93658: GTK needs name to render cell renderer "natively"

        @Override

        public String getName() {

            String name = super.getName();

            return name == null ? "ComboBox.renderer" : name;  // NOI18N

        }

    }

    /**

     * Registers a change listener.

     * Registered change listeners are notified when acceptability

     * of values in the form changes.

     *

     * @param  l  listener to be registered

     * @see  #isAcceptable

     * @see  #removeChangeListener

     */

    private void addChangeListener(ChangeListener l) {

        if (changeListeners == null) {

            changeListeners = new ArrayList<ChangeListener>(3);

        }

        changeListeners.add(l);

    }

    /**

     * Unregisters the given change listener.

     * If the given listener has not been registered before, calling this

     * method does not have any effect.

     *

     * @param  l  change listener to be removed

     * @see  #addChangeListener

     */

    private void removeChangeListener(ChangeListener l) {

        if (changeListeners != null

                && changeListeners.remove(l)

                && changeListeners.isEmpty()) {

            changeListeners = null;

        }

    }

    /**

     * Notifies all registered change listeners about a change.

     *

     * @see  #addChangeListener

     */

    private void fireStateChange() {

        if (changeListeners != null) {

            ChangeEvent e = new ChangeEvent(this);

            for (Iterator i = changeListeners.iterator(); i.hasNext(); ) {

                ((ChangeListener) i.next()).stateChanged(e);

            }

        }

    }

    /**

     * Disables all interactive visual components of this dialog

     * except the OK, Cancel and Help buttons.

     */

    private void disableComponents() {

        final Stack<Container> stack = new Stack<Container>();

        stack.push(this);

        while (!stack.empty()) {

            Container container = stack.pop();

            Component comps[] = container.getComponents();

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

                final java.awt.Component comp = comps[i];

                if (comp == txtAreaMessage) {

                    continue;

                }

                if (comp instanceof JPanel) {

                    JPanel panel = (JPanel) comp;

                    stack.push(panel);

                    final Border border = panel.getBorder();

                    if (border != null) {

                        disableBorderTitles(border);

                    }

                    continue;

                }

                comp.setEnabled(false);

                if (comp instanceof java.awt.Container) {

                    Container nestedCont = (Container) comp;

                    if (nestedCont.getComponentCount() != 0) {

                        stack.push(nestedCont);

                    }

                }

            }

        }

    }

    /**

     */

    private static void disableBorderTitles(Border border) {

        if (border instanceof TitledBorder) {

            disableBorderTitle((TitledBorder) border);

            return;

        }

        if (!(border instanceof CompoundBorder)) {

            return;

        }

        Stack<CompoundBorder> stack = new Stack<CompoundBorder>();

        stack.push((CompoundBorder) border);

        while (!stack.empty()) {

            CompoundBorder cb = stack.pop();

            Border b;

            b = cb.getOutsideBorder();

            if (b instanceof CompoundBorder) {

                stack.push((CompoundBorder) b);

            } else if (b instanceof TitledBorder) {

                disableBorderTitle((TitledBorder) b);

            }

            b = cb.getInsideBorder();

            if (b instanceof CompoundBorder) {

                stack.push((CompoundBorder) b);

            } else if (b instanceof TitledBorder) {

                disableBorderTitle((TitledBorder) b);

            }

        }

    }

    /**

     */

    private static void disableBorderTitle(TitledBorder border) {

        final Color color = UIManager.getColor(

                "Label.disabledForeground");                        //NOI18N

        if (color != null) {

            border.setTitleColor(color);

        }

    }

    private JLabel lblClassToTestValue;

    private ClassNameTextField tfClassName;

    private JTextComponent txtAreaMessage;

    private JComboBox cboxLocation;

    private JComboBox cboxFramework;

    private JCheckBox chkAbstractImpl;

    private JCheckBox chkComments;

    private JCheckBox chkContent;

    private JCheckBox chkExceptions;

    private JCheckBox chkGenerateSuites;

    private JCheckBox chkJavaDoc;

    private JCheckBox chkPackage;

    private JCheckBox chkPackagePrivateClasses;

    private JCheckBox chkProtected;

    private JCheckBox chkPublic;

    private JCheckBox chkSetUp;

    private JCheckBox chkTearDown;

}

/*

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

 *

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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 2004-2007 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.netbeans.modules.gsf.testrunner;

//import org.netbeans.modules.junit.GuiUtils;

//import org.netbeans.modules.junit.CommonSettings;

import org.netbeans.modules.gsf.testrunner.api.GuiUtils;

import org.netbeans.modules.gsf.testrunner.api.CommonSettings;

import org.openide.loaders.TemplateWizard;

/**

 * Wizard for an empty test case.

 *

 * @author  Marian Petras

 */

public class EmptyTestCaseWizard extends TemplateWizard {

    /** name of property "package" */

    static final String PROP_PACKAGE = "package";                       //NOI18N

    /** name of property "class name" */

    static final String PROP_CLASS_NAME = "className";                  //NOI18N

    // PENDING - should not be hard-coded:

    static final String TESTS_ROOT_NAME = "test";               //NOI18N

    /**

     * initializes the settings for the settings panel

     */

    @Override

    public void initialize() {

        CommonSettings settings = CommonSettings.getDefault();

        putProperty(GuiUtils.CHK_SETUP,

                    Boolean.valueOf(settings.isGenerateSetUp()));

        putProperty(GuiUtils.CHK_TEARDOWN,

                    Boolean.valueOf(settings.isGenerateTearDown()));

        putProperty(GuiUtils.CHK_HINTS,

                    Boolean.valueOf(settings.isBodyComments()));

    }

}

/*

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

 *

 * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * 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.  Oracle designates this

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

 * by Oracle 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 2004-2007 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.netbeans.modules.gsf.testrunner;

import org.netbeans.modules.gsf.testrunner.EmptyTestCaseWizard;

import org.netbeans.modules.gsf.testrunner.api.CommonTestUtil;

import java.io.IOException;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.netbeans.api.java.project.JavaProjectConstants;

import org.netbeans.api.java.queries.UnitTestForSourceQuery;

import org.netbeans.api.project.FileOwnerQuery;

import org.netbeans.api.project.Project;

import org.netbeans.api.project.ProjectUtils;

import org.netbeans.api.project.SourceGroup;

//import org.netbeans.modules.junit.CommonTestUtil;

import org.openide.ErrorManager;

import org.openide.cookies.EditorCookie;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.filesystems.URLMapper;

import org.openide.loaders.DataObject;

import org.openide.loaders.DataObjectNotFoundException;

import org.openide.text.Line;

import org.openide.text.Line.ShowOpenType;

import org.openide.text.Line.ShowVisibilityType;

import org.openide.util.Utilities;

/**

 *

 * @author  Marian Petras

 */

public final class Utils {

    /** */

    private final Project project;

    /** <!-- PENDING --> */

    private boolean sourceGroupsOnly = true;

    /** <!-- PENDING --> */

    private SourceGroup[] javaSourceGroups;

    /** <!-- PENDING --> */

    private Map<SourceGroup,Object[]> sourcesToTestsMap;

    /** <!-- PENDING --> */

    private Map<FileObject,Object> foldersToSourceGroupsMap;

    /**

     * <!-- PENDING -->

     */

    public Utils(Project project) {

        this.project = project;

    }

    /** <!-- PENDING --> */

    static FileObject findTestsRoot(Project project) {

        final SourceGroup[] sourceGroups

                = new Utils(project).getJavaSourceGroups();

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

            FileObject root = sourceGroups[i].getRootFolder();

            if (root.getName().equals(EmptyTestCaseWizard.TESTS_ROOT_NAME)) {

                return root;

            }

        }

        return null;

    }

    /** */

    static FileObject getPackageFolder(

            FileObject root,

            String pkgName) throws IOException {

        String relativePathName = pkgName.replace('.', '/');

        FileObject folder = root.getFileObject(relativePathName);

        if (folder == null) {

            folder = FileUtil.createFolder(root, relativePathName);

        }

        return folder;

    }

    /**

     * Identifies and collects <code>SourceGroup</code>s and folders

     * of a given project which may serve as target folders for newly created

     * test classes.

     *

     * @param  project  project whose folders are to be checked

     * @param  sourceGroupsOnly  return only <code>SourceGroup</code>s

     *                           - ignore target folders not having

     *                           a corresponding <code>SourceGroup</code>

     * @return  collection which may contain <code>FileObject</code>s

     *          or <code>SourceGroup</code>s (or both);

     *          it may be empty but not <code>null</code>

     * @author  Marian Petras

     */

    static Collection getTestTargets(Project project,

                                     final boolean sourceGroupsOnly) {

        final Utils utils = new Utils(project);

        return utils.getTestTargets(sourceGroupsOnly);

    }

    /**

     * Identifies and collects root test folders of a given project.

     * 

     * @param  project  project whose test folders are to be found

     * @return  collection of found {@code FileObject}s, possibly empty

     *          (but not {@code null})

     */

    public static Collection<FileObject> getTestFolders(Project project) {

        return new Utils(project).getTestFolders();

    }

    /**

     * Builds a map that containing relation between <code>SourceGroup</code>s

     * and their respective test <code>SourceGroup</code>s.

     * Each entry of the map contains a <code>SourceGroup</code> as a key

     * and an array of test <code>SourceGroup</code>s returned by

     * <code>UnitTestForSourceQuery</code> for that <code>SourceGroup</code>

     * as a value. <code>SourceGroup</code>s that have no test

     * <code>SourceGroup</code>s assigned are omitted, i.e. the resulting

     * map does not contain entries that would have empty arrays as their

     * values.

     *

     * @param  project  project whose <code>SourceGroup</code>s are to be

     *                  checked

     * @param  sourceGroupsOnly  return only <code>SourceGroup</code>s

     *                           - ignore test folders not having

     *                           a corresponding <code>SourceGroup</code>

     * @return  created map - may be empty, may be unmodifiable

     *                        never <code>null</code>

     */

    static Map getSourcesToTestsMap(Project project,

                                    final boolean sourceGroupsOnly) {

        final Utils utils = new Utils(project);

        return utils.getSourcesToTestsMap(sourceGroupsOnly);

    }

    /**

     * <!-- PENDING -->

     */

    Project getProject() {

        return project;

    }

    /**

     * Identifies and collects root test folders of the project.

     * 

     * @return  collection of found {@code FileObject}s

     *          - may be empty but never {@code null}

     */

    private Collection<FileObject> getTestFolders() {

        /*

         * Idea:

         * 1) Get all SourceGroups

         * 2) For each SourceGroup, ask UnitTestForSourceQuery for its related

         *    test SourceGroups

         */

        /* .) get all SourceGroups: */

        final SourceGroup[] sourceGroups = getJavaSourceGroups();

        if (sourceGroups.length == 0) {

            return Collections.<FileObject>emptyList();

        }

        List<FileObject> result = null;

        /* .) for each SourceGroup, ask for test root folders: */

        for (SourceGroup sourceGroup : sourceGroups) {

            FileObject srcFolder = sourceGroup.getRootFolder();

            FileObject[] tstFoldersRaw = getTestFoldersRaw(srcFolder);

            if (tstFoldersRaw.length == 0) {

                continue;

            }

            for (FileObject tstFolder : tstFoldersRaw) {

                if (tstFolder == null) {

                    continue;

                }

                if (result == null) {

                    result = new ArrayList<FileObject>(2);

                }

                if (!result.contains(tstFolder)) {

                    result.add(tstFolder);

                }

            }

        }

        /* .) pack the results: */

        if (result == null) {

            return Collections.<FileObject>emptyList();

        } else {

            assert !result.isEmpty();

            return (result.size() == 1)

                   ? Collections.<FileObject>singleton(result.get(0))

                   : result;

        }

    }

    /**

     * Identifies and collects <code>SourceGroup</code>s and folders

     * which may serve as target folders for newly created test classes.

     *

     * @param  sourceGroupsOnly  return only <code>SourceGroup</code>s

     *                           (skip target folders without matching

     *                           <code>SourceGroup</code>)

     * @return  collection which may contain <code>FileObject</code>s

     *          or <code>SourceGroup</code>s (or both);

     *          it may be empty but not <code>null</code>

     * @see  #getTestTargets(Project, boolean)

     * @author  Marian Petras

     */

    private Collection<Object> getTestTargets(final boolean sourceGroupsOnly) {

        /*

         * Idea:

         * 1) Get all SourceGroups

         * 2) For each SourceGroup, ask UnitTestForSourceQuery for its related

         *    test SourceGroups

         *

         * Union of all SourceGroups returned by UnitTestForSourceQuery

         * are the test SourceGroups.

         */

        /* .) get all SourceGroups: */

        final SourceGroup[] sourceGroups = getJavaSourceGroups();

        if (sourceGroups.length == 0) {

            return Collections.<Object>emptyList();

        }

        /* .) */

        createFoldersToSourceGroupsMap(sourceGroups);

        Object testTargetsUnion[] = new Object[sourceGroups.length];

        int size = 0;

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

            Object[] testTargets = getTestTargets(sourceGroups[i],

                                                  sourceGroupsOnly);

            size = merge(testTargets, testTargetsUnion, size);

        }

        if (size != testTargetsUnion.length) {

            testTargetsUnion = CommonTestUtil.skipNulls(testTargetsUnion, new Object[0]);

        }

        return Collections.unmodifiableCollection(

                      Arrays.asList(testTargetsUnion));

    }

    /**

     * <!-- PENDING -->

     */

    Map<SourceGroup,Object[]> getSourcesToTestsMap() {

        if (sourcesToTestsMap == null) {

            sourcesToTestsMap = createSourcesToTestsMap(sourceGroupsOnly);

        }

        return sourcesToTestsMap;

    }

    /**

     * <!-- PENDING -->

     */

    Map<SourceGroup,Object[]> getSourcesToTestsMap(final boolean sourceGroupsOnly) {

        if (sourceGroupsOnly != this.sourceGroupsOnly) {

            sourcesToTestsMap = null;

            this.sourceGroupsOnly = sourceGroupsOnly;

        }

        return getSourcesToTestsMap();

    }

    /**

     * Builds a map that containing relation between <code>SourceGroup</code>s

     * and their respective test <code>SourceGroup</code>s.

     * Each entry of the map contains a <code>SourceGroup</code> as a key

     * and an array of test <code>SourceGroup</code>s returned by

     * <code>UnitTestForSourceQuery</code> for that <code>SourceGroup</code>

     * as a value. <code>SourceGroup</code>s that have no test

     * <code>SourceGroup</code>s assigned are omitted, i.e. the resulting

     * map does not contain entries that would have empty arrays as their

     * values.

     *

     * @param  sourceGroupsOnly  return only <code>SourceGroup</code>s

     *                           - ignore test folders not having

     *                           a corresponding <code>SourceGroup</code>

     * @return  created map - may be empty, may be unmodifiable,

     *                        cannot be <code>null</code>

     */

    private Map<SourceGroup,Object[]> createSourcesToTestsMap(final boolean sourceGroupsOnly) {

        /*

         * Idea:

         * 1) Get all SourceGroups

         * 2) For each SourceGroup, ask UnitTestForSourceQuery for its related

         *    test SourceGroups

         */

        /* .) get all SourceGroups: */

        final SourceGroup[] sourceGroups = getJavaSourceGroups();

        if (sourceGroups.length == 0) {

            return Collections.<SourceGroup,Object[]>emptyMap();

        }

        /* .) get test SourceGroups for each SourceGroup: */

        createFoldersToSourceGroupsMap(sourceGroups);

        Object testTargetsUnion[] = new Object[sourceGroups.length];

        Map<SourceGroup,Object[]> map;

        map = new HashMap<SourceGroup,Object[]>(

                            (int) ((float) sourceGroups.length * 1.33f + 0.5f),

                            .75f);

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

            Object[] testTargets = getTestTargets(sourceGroups[i],

                                                  sourceGroupsOnly);

            if (testTargets.length != 0) {

                map.put(sourceGroups[i], testTargets);

            }

        }

        if (map.isEmpty()) {

            return Collections.<SourceGroup,Object[]>emptyMap();

        }

        if (map.size() == 1) {

            Map.Entry<SourceGroup,Object[]> entry

                    = map.entrySet().iterator().next();

            return Collections.singletonMap(entry.getKey(), entry.getValue());

        }

        final int finalMapSize = map.size();

        if (finalMapSize >= (sourceGroups.length - 5)) {

            return map;

        }

        final Map<SourceGroup,Object[]> targetMap;

        targetMap = new HashMap<SourceGroup,Object[]>(

                                    (int) ((float) finalMapSize * 1.25f + .5f),

                                    .8f);

        targetMap.putAll(map);

        return targetMap;

    }

    /**

     * Merges a given set of <code>FileObject</code>s and

     * <code>SourceGroup</code>s to the given target set (which may contain

     * same types of elements).

     * The source set (array) is not modified during merge. The target

     * set (array) is not modified otherwise than by adding (overwriting

     * <code>null</code>s) elements from the source set or by replacing elements

     * with equivalent elements (i.e. pointing to the same folder). Elements are

     * always added after the last non-<code>null</code> element of the target

     * set. After the merge, it is guaranteed that all <code>null</code>

     * elements of the target array are located at the end. The above

     * constraints can only be fulfilled if parameter

     * <code>currTargetSetSize</code> is correct and if all <code>null</code>

     * elements of the target set are placed at the end of the array at the

     * moment this method is called. The target array must contain enough

     * <code>null</code> elements so that all elements to be added to the set

     * can fit.

     *

     * @param  setToAdd  elements to be added to the target set

     *                   - must not contain <code>null</code> elements

     * @param  targetSet  array to add elements to

     * @param  currTargetSetSize  current count of non-null elements in the

     *                            target set (<code>null</code> elements are

     *                            always at the end of the array)

     * @return  new size of the target set

     *          (number of non-<code>null</code> elements)

     */

    private static int merge(final Object[] setToAdd,

                             final Object[] targetSet,

                             final int currTargetSetSize) {

        if (setToAdd.length == 0) {

            return currTargetSetSize;

        }

        if (currTargetSetSize == 0) {

            System.arraycopy(setToAdd, 0, targetSet, 0, setToAdd.length);

            return setToAdd.length;

        }

        int targetSetSize = currTargetSetSize;

        toAdd:

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

            final Object objToAdd = setToAdd[i];

            for (int j = 0; j < targetSetSize; j++) {

                final Object chosen = chooseTarget(targetSet[j], objToAdd);

                if (chosen != null) {           //both point to the same folder

                    targetSet[j] = chosen;

                    continue toAdd;

                }

            }

            targetSet[targetSetSize++] = objToAdd;

        }

        return targetSetSize;

    }

    /**

     * Finds whether the given two objects defining a target folder are equal

     * or not and if so, suggests which one is preferred.

     * Each of the folder targets may be either a <code>SourceGroup<code>

     * object or a <code>FileObject</code> folder. If both targets point

     * to the same folder, one of them which is preferred is returned.

     * Otherwise <code>null</code> is returned.

     * <p>

     * If both targets are <code>SourceGroup</code>s, the first target is used.

     * If none of the targets is a <code>SourceGroup</code>, the first target is

     * used.

     * Otherwise (i.e. one target is a <code>SourceGroup</code>,

     * the other is not), the <code>SourceGroup</code> target is returned.

     *

     * @param  target1  one target

     * @param  target2  second target

     * @return  <code>null</code> if the two targets define different folders;

     *          or the preferred one (of the passed targets) if the two

     *          are equal

     */

    private static Object chooseTarget(Object target1, Object target2) {

        final boolean isGroup1 = target1 instanceof SourceGroup;

        final boolean isGroup2 = target2 instanceof SourceGroup;

        assert isGroup1 || (target1 instanceof FileObject);

        assert isGroup2 || (target2 instanceof FileObject);

        if (isGroup1 && isGroup2 && target1.equals(target2)) {

            return target1;

        }

        final FileObject folder1 = isGroup1

                                   ? ((SourceGroup) target1).getRootFolder()

                                   : ((FileObject) target1);

        final FileObject folder2 = isGroup2

                                   ? ((SourceGroup) target2).getRootFolder()

                                   : ((FileObject) target2);

        if (!(folder1.isFolder())) {

            throw new IllegalArgumentException("target1: not a folder");//NOI18N

        }

        if (!(folder2.isFolder())) {

            throw new IllegalArgumentException("target2: not a folder");//NOI18N

        }

        if (folder1.equals(folder2)) {

            return (isGroup1 == isGroup2) ? target1

                                          : (isGroup1 ? target1 : target2);

        }

        return null;

    }

    /**

     * Returns test targets for the given <code>SourceGroup</code>.

     * The test targets are folders which are searched when tests for a class

     * from the <code>SourceGroup</code> are to be found. Each of the returned

     * test targets may be either <code>SourceGroup</code> (representing

     * a folder plus additional information such as display name) or simply

     * a <code>FileObject</code> representing a folder.

     * If parameter <code>includeSourceGroups</code> is <code>false</code>,

     * only <code>SourceGroup<code>s are returned (target folders without

     * corresponding <code>SourceGroup</code>s are ignored).

     *

     * @param  src  source group to find test targets for

     * @param  sourceGroupsOnly  skip target folders without matching

     *                           <code>SourceGroup</code>

     * @return  array which may contain <code>FileObject</code>s

     *          or <code>SourceGroup</code>s (or both);

     *          it may be empty but not <code>null</code>

     * @see  CommonTestUtil#getFileObject2SourceGroupMap

     */

    public Object[] getTestTargets(SourceGroup sourceGroup,

                                   final boolean sourceGroupsOnly) {

        /* .) find test root folders: */

        final FileObject[] testFolders

                    = getTestFoldersRaw(sourceGroup.getRootFolder());

        if (testFolders.length == 0) {

            return new Object[0];

        }

        /* .) find SourceGroups corresponding to the FileObjects: */

        final Object[] targets = new Object[testFolders.length];

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

            final FileObject testFolder = testFolders[i];

            if (testFolder == null) {

                continue;

            }

            Object srcGroup = foldersToSourceGroupsMap.get(testFolder);

            targets[i] = (srcGroup != null)

                         ? srcGroup

                         : sourceGroupsOnly ? null : testFolder;

        }

        return CommonTestUtil.skipNulls(targets, new Object[0]);

    }

    /**

     * Returns an array of test folders corresponding to the given source

     * folder - may contain <code>null</code>s.

     *

     * @param  srcFolder  <code>FileObject</code> representing source code root,

     *                    for which test root folders should be found

     * @return  array of <code>FileObject</code>s representing test root

     *          folders, possibly with superfluous <code>null</code> elements

     * @see  #getSourceFoldersRaw

     */

    public FileObject[] getTestFoldersRaw(FileObject srcFolder) {

        return getFileObjects(UnitTestForSourceQuery.findUnitTests(srcFolder),

                              true);

    }

    /**

     * Returns an array of source folders corresponding to the given test

     * folder - may contain <code>null</code>s.

     *

     * @param  srcFolder  <code>FileObject</code> representing source code root,

     *                    for which source root folders should be found

     * @return  array of <code>FileObject</code>s representing source root

     *          folders, possibly with superfluous <code>null</code> elements

     * @see  #getTestFoldersRaw

     */

    public FileObject[] getSourceFoldersRaw(FileObject testFolder) {

        return getFileObjects(UnitTestForSourceQuery.findSources(testFolder),

                              false);

    }

    /**

     * Returns <code>FileObject</code>s represented by the given URLs.

     *

     * @param  rootURLs  URLs representing <code>FileObject</code>s

     * @param  srcToTest  <code>true</code> if we are searching for test

     *                    folders, <code>false</code> if we are searching

     *                    for source folders - affects only text of warning

     *                    log messages

     * @return  array of <code>FileObject</code>s representing source root

     *          folders, possibly with superfluous <code>null</code> elements

     */

    private FileObject[] getFileObjects(final URL[] rootURLs,

                                        final boolean srcToTest) {

        if (rootURLs.length == 0) {

            return new FileObject[0];

        }

        FileObject[] sourceRoots = new FileObject[rootURLs.length];

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

            if ((sourceRoots[i] = URLMapper.findFileObject(rootURLs[i]))

                    == null) {

                final int severity = ErrorManager.INFORMATIONAL;

                if (ErrorManager.getDefault().isLoggable(severity)) {

                    ErrorManager.getDefault().log(

                            severity,

                            (srcToTest ? "Test" : "Source")             //NOI18N

                            + " directory " + rootURLs[i]               //NOI18N

                            + " declared by project "                   //NOI18N

                            + ProjectUtils.getInformation(project).getName()

                            + " does not exist.");                      //NOI18N

                }

                continue;

            }

            Project sourceRootOwner = FileOwnerQuery.getOwner(sourceRoots[i]);

            if (!project.equals(sourceRootOwner)) {

                sourceRoots[i] = null;

                int severity = ErrorManager.INFORMATIONAL;

                if (ErrorManager.getDefault().isNotifiable(severity)) {

                    ErrorManager.getDefault().notify(

                        severity,

                        new IllegalStateException(

                            "Malformed project: Found test root (" +    //NOI18N

                                rootURLs[i] + ')' + ' ' +

                                (sourceRootOwner == null

                                        ? "does not belong to any"      //NOI18N

                                        : "belongs to a different") +   //NOI18N

                                " project."));                          //NOI18N

                }

                continue;

            }

        }

        return sourceRoots;

    }

    /**

     */

    public static FileObject[] skipNulls(final FileObject[] fileObjs) {

        if (fileObjs.length == 0) {

            return fileObjs;

        }

        int nullsCount = 0;

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

            if (fileObjs[i] == null) {

                nullsCount++;

            }

        }

        if (nullsCount == 0) {

            return fileObjs;

        }

        if (nullsCount == fileObjs.length) {

            return new FileObject[0];

        }

        final FileObject[] fileObjsNew

                = new FileObject[fileObjs.length - nullsCount];

        int index = 0, indexNew = 0;

        while (indexNew < fileObjsNew.length) {

            FileObject fileObj = fileObjs[index++];

            if (fileObj != null) {

                fileObjsNew[indexNew++] = fileObj;

            }

        }

        return fileObjsNew;

    }

    /**

     * Creates a map mapping folders to source groups.