effectively unqualified: take parenthesis around qualifier into account
[idea/community.git] / plugins / junit / src / com / intellij / execution / junit2 / configuration / JUnitConfigurable.java
1 /*
2  * Copyright 2000-2016 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.intellij.execution.junit2.configuration;
18
19 import com.intellij.application.options.ModuleDescriptionsComboBox;
20 import com.intellij.execution.ExecutionBundle;
21 import com.intellij.execution.MethodBrowser;
22 import com.intellij.execution.ShortenCommandLine;
23 import com.intellij.execution.configuration.BrowseModuleValueActionListener;
24 import com.intellij.execution.junit.JUnitConfiguration;
25 import com.intellij.execution.junit.JUnitConfigurationType;
26 import com.intellij.execution.junit.JUnitUtil;
27 import com.intellij.execution.junit.TestClassFilter;
28 import com.intellij.execution.testframework.SourceScope;
29 import com.intellij.execution.testframework.TestSearchScope;
30 import com.intellij.execution.ui.*;
31 import com.intellij.ide.util.ClassFilter;
32 import com.intellij.ide.util.PackageChooserDialog;
33 import com.intellij.openapi.fileChooser.FileChooser;
34 import com.intellij.openapi.fileChooser.FileChooserDescriptor;
35 import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
36 import com.intellij.openapi.fileChooser.FileChooserFactory;
37 import com.intellij.openapi.fileTypes.PlainTextLanguage;
38 import com.intellij.openapi.module.Module;
39 import com.intellij.openapi.options.SettingsEditor;
40 import com.intellij.openapi.project.Project;
41 import com.intellij.openapi.ui.ComponentWithBrowseButton;
42 import com.intellij.openapi.ui.LabeledComponent;
43 import com.intellij.openapi.ui.TextFieldWithBrowseButton;
44 import com.intellij.openapi.ui.ex.MessagesEx;
45 import com.intellij.openapi.util.Condition;
46 import com.intellij.openapi.util.io.FileUtil;
47 import com.intellij.openapi.util.registry.Registry;
48 import com.intellij.openapi.util.text.StringUtil;
49 import com.intellij.openapi.vcs.changes.ChangeListManager;
50 import com.intellij.openapi.vcs.changes.LocalChangeList;
51 import com.intellij.openapi.vfs.VirtualFile;
52 import com.intellij.psi.*;
53 import com.intellij.psi.search.GlobalSearchScope;
54 import com.intellij.rt.execution.junit.RepeatCount;
55 import com.intellij.ui.*;
56 import com.intellij.ui.components.JBLabel;
57 import com.intellij.ui.components.fields.ExpandableTextField;
58 import com.intellij.util.IconUtil;
59 import com.intellij.util.ui.UIUtil;
60 import gnu.trove.TIntArrayList;
61 import org.jetbrains.annotations.NotNull;
62
63 import javax.swing.*;
64 import javax.swing.event.ChangeEvent;
65 import javax.swing.event.ChangeListener;
66 import javax.swing.text.Document;
67 import javax.swing.text.PlainDocument;
68 import java.awt.*;
69 import java.awt.event.ActionEvent;
70 import java.awt.event.ActionListener;
71 import java.util.Arrays;
72 import java.util.List;
73
74 public class JUnitConfigurable<T extends JUnitConfiguration> extends SettingsEditor<T> implements PanelWithAnchor {
75   private static final List<TIntArrayList> ourEnabledFields = Arrays.asList(
76     new TIntArrayList(new int[]{0}),
77     new TIntArrayList(new int[]{1}),
78     new TIntArrayList(new int[]{1, 2}),
79     new TIntArrayList(new int[]{3}),
80     new TIntArrayList(new int[]{4}),
81     new TIntArrayList(new int[]{5}),
82     new TIntArrayList(new int[]{1, 2}),
83     new TIntArrayList(new int[]{6})
84     );
85   private static final String[] FORK_MODE_ALL =
86     {JUnitConfiguration.FORK_NONE, JUnitConfiguration.FORK_METHOD, JUnitConfiguration.FORK_KLASS};
87   private static final String[] FORK_MODE = {JUnitConfiguration.FORK_NONE, JUnitConfiguration.FORK_METHOD};
88   private final ConfigurationModuleSelector myModuleSelector;
89   private final LabeledComponent[] myTestLocations = new LabeledComponent[6];
90   private final JUnitConfigurationModel myModel;
91   private final BrowseModuleValueActionListener[] myBrowsers;
92   private JComponent myPackagePanel;
93   private LabeledComponent<EditorTextFieldWithBrowseButton> myPackage;
94   private LabeledComponent<TextFieldWithBrowseButton> myDir;
95   private LabeledComponent<JPanel> myPattern;
96   private LabeledComponent<EditorTextFieldWithBrowseButton> myClass;
97   private LabeledComponent<EditorTextFieldWithBrowseButton> myMethod;
98   private LabeledComponent<EditorTextFieldWithBrowseButton> myCategory;
99   // Fields
100   private JPanel myWholePanel;
101   private LabeledComponent<ModuleDescriptionsComboBox> myModule;
102   private CommonJavaParametersPanel myCommonJavaParameters;
103   private JRadioButton myWholeProjectScope;
104   private JRadioButton mySingleModuleScope;
105   private JRadioButton myModuleWDScope;
106   private TextFieldWithBrowseButton myPatternTextField;
107   private JrePathEditor myJrePathEditor;
108   private LabeledComponent<ShortenCommandLineModeCombo> myShortenClasspathModeCombo;
109   private JComboBox myForkCb;
110   private JBLabel myTestLabel;
111   private JComboBox myTypeChooser;
112   private JBLabel mySearchForTestsLabel;
113   private JPanel myScopesPanel;
114   private JComboBox myRepeatCb;
115   private JTextField myRepeatCountField;
116   private LabeledComponent<JComboBox<String>> myChangeListLabeledComponent;
117   private LabeledComponent<RawCommandLineEditor> myUniqueIdField;
118   private Project myProject;
119   private JComponent anchor;
120
121   public JUnitConfigurable(final Project project) {
122     myProject = project;
123     myModel = new JUnitConfigurationModel(project);
124     myModuleSelector = new ConfigurationModuleSelector(project, getModulesComponent());
125     myJrePathEditor.setDefaultJreSelector(DefaultJreSelector.fromModuleDependencies(getModulesComponent(), false));
126     myCommonJavaParameters.setModuleContext(myModuleSelector.getModule());
127     myCommonJavaParameters.setHasModuleMacro();
128     myModule.getComponent().addActionListener(new ActionListener() {
129       public void actionPerformed(ActionEvent e) {
130         myCommonJavaParameters.setModuleContext(myModuleSelector.getModule());
131       }
132     });
133     myBrowsers = new BrowseModuleValueActionListener[]{
134       new PackageChooserActionListener(project),
135       new TestClassBrowser(project),
136       new MethodBrowser(project) {
137         protected Condition<PsiMethod> getFilter(PsiClass testClass) {
138           return new JUnitUtil.TestMethodFilter(testClass);
139         }
140
141         @Override
142         protected String getClassName() {
143           return JUnitConfigurable.this.getClassName();
144         }
145
146         @Override
147         protected ConfigurationModuleSelector getModuleSelector() {
148           return myModuleSelector;
149         }
150       },
151       new TestsChooserActionListener(project),
152       new BrowseModuleValueActionListener(project) {
153         @Override
154         protected String showDialog() {
155           final VirtualFile virtualFile =
156             FileChooser.chooseFile(FileChooserDescriptorFactory.createSingleFolderDescriptor(), project, null);
157           if (virtualFile != null) {
158             return FileUtil.toSystemDependentName(virtualFile.getPath());
159           }
160           return null;
161         }
162       },
163       new CategoryBrowser(project),
164       null
165     };
166     // Garbage support
167     final DefaultComboBoxModel aModel = new DefaultComboBoxModel();
168     aModel.addElement(JUnitConfigurationModel.ALL_IN_PACKAGE);
169     aModel.addElement(JUnitConfigurationModel.DIR);
170     aModel.addElement(JUnitConfigurationModel.PATTERN);
171     aModel.addElement(JUnitConfigurationModel.CLASS);
172     aModel.addElement(JUnitConfigurationModel.METHOD);
173     aModel.addElement(JUnitConfigurationModel.CATEGORY);
174     aModel.addElement(JUnitConfigurationModel.UNIQUE_ID);
175     if (Registry.is("testDiscovery.enabled")) {
176       aModel.addElement(JUnitConfigurationModel.BY_SOURCE_POSITION);
177       aModel.addElement(JUnitConfigurationModel.BY_SOURCE_CHANGES);
178     }
179     myTypeChooser.setModel(aModel);
180     myTypeChooser.setRenderer(new ListCellRendererWrapper<Integer>() {
181       @Override
182       public void customize(JList list, Integer value, int index, boolean selected, boolean hasFocus) {
183         switch (value) {
184           case JUnitConfigurationModel.ALL_IN_PACKAGE:
185             setText("All in package");
186             break;
187           case JUnitConfigurationModel.DIR:
188             setText("All in directory");
189             break;
190           case JUnitConfigurationModel.PATTERN:
191             setText("Pattern");
192             break;
193           case JUnitConfigurationModel.CLASS:
194             setText("Class");
195             break;
196           case JUnitConfigurationModel.METHOD:
197             setText("Method");
198             break;
199           case JUnitConfigurationModel.CATEGORY:
200             setText("Category");
201             break;
202           case JUnitConfigurationModel.UNIQUE_ID:
203             setText("UniqueId");
204             break;
205           case JUnitConfigurationModel.BY_SOURCE_POSITION:
206             setText("Through source location");
207             break;
208           case JUnitConfigurationModel.BY_SOURCE_CHANGES:
209             setText("Over changes in sources");
210             break;
211         }
212       }
213     });
214
215     myTestLocations[JUnitConfigurationModel.ALL_IN_PACKAGE] = myPackage;
216     myTestLocations[JUnitConfigurationModel.CLASS] = myClass;
217     myTestLocations[JUnitConfigurationModel.METHOD] = myMethod;
218     myTestLocations[JUnitConfigurationModel.DIR] = myDir;
219     myTestLocations[JUnitConfigurationModel.CATEGORY] = myCategory;
220
221     myRepeatCb.setModel(new DefaultComboBoxModel(RepeatCount.REPEAT_TYPES));
222     myRepeatCb.setSelectedItem(RepeatCount.ONCE);
223     myRepeatCb.addActionListener(new ActionListener() {
224       @Override
225       public void actionPerformed(ActionEvent e) {
226         myRepeatCountField.setEnabled(RepeatCount.N.equals(myRepeatCb.getSelectedItem()));
227       }
228     });
229
230     final JPanel panel = myPattern.getComponent();
231     panel.setLayout(new BorderLayout());
232     myPatternTextField = new TextFieldWithBrowseButton(new ExpandableTextField());
233     myPatternTextField.setButtonIcon(IconUtil.getAddIcon());
234     panel.add(myPatternTextField, BorderLayout.CENTER);
235     myTestLocations[JUnitConfigurationModel.PATTERN] = myPattern;
236
237     final FileChooserDescriptor dirFileChooser = FileChooserDescriptorFactory.createSingleFolderDescriptor();
238     dirFileChooser.setHideIgnored(false);
239     final JTextField textField = myDir.getComponent().getTextField();
240     InsertPathAction.addTo(textField, dirFileChooser);
241     FileChooserFactory.getInstance().installFileCompletion(textField, dirFileChooser, true, null);
242     // Done
243
244     myModel.setListener(this);
245
246     myTypeChooser.addActionListener(new ActionListener() {
247       @Override
248       public void actionPerformed(ActionEvent e) {
249         final Object selectedItem = myTypeChooser.getSelectedItem();
250         myModel.setType((Integer)selectedItem);
251         changePanel();
252       }
253     }
254     );
255
256     myRepeatCb.addActionListener(new ActionListener() {
257       @Override
258       public void actionPerformed(ActionEvent e) {
259         if ((Integer) myTypeChooser.getSelectedItem() == JUnitConfigurationModel.CLASS) {
260           myForkCb.setModel(getForkModelBasedOnRepeat());
261         }
262       }
263     });
264     myModel.setType(JUnitConfigurationModel.CLASS);
265     installDocuments();
266     addRadioButtonsListeners(new JRadioButton[]{myWholeProjectScope, mySingleModuleScope, myModuleWDScope}, null);
267     myWholeProjectScope.addChangeListener(new ChangeListener() {
268       public void stateChanged(final ChangeEvent e) {
269         onScopeChanged();
270       }
271     });
272
273     UIUtil.setEnabled(myCommonJavaParameters.getProgramParametersComponent(), false, true);
274
275     setAnchor(mySearchForTestsLabel);
276     myJrePathEditor.setAnchor(myModule.getLabel());
277     myCommonJavaParameters.setAnchor(myModule.getLabel());
278     myShortenClasspathModeCombo.setAnchor(myModule.getLabel());
279
280     final DefaultComboBoxModel<String> model = new DefaultComboBoxModel<>();
281     myChangeListLabeledComponent.getComponent().setModel(model);
282     model.addElement("All");
283
284     final List<LocalChangeList> changeLists = ChangeListManager.getInstance(project).getChangeLists();
285     for (LocalChangeList changeList : changeLists) {
286       model.addElement(changeList.getName());
287     }
288
289     myShortenClasspathModeCombo.setComponent(new ShortenCommandLineModeCombo(myProject, myJrePathEditor, myModule.getComponent()));
290   }
291
292   private static void addRadioButtonsListeners(final JRadioButton[] radioButtons, ChangeListener listener) {
293     final ButtonGroup group = new ButtonGroup();
294     for (final JRadioButton radioButton : radioButtons) {
295       radioButton.getModel().addChangeListener(listener);
296       group.add(radioButton);
297     }
298     if (group.getSelection() == null) group.setSelected(radioButtons[0].getModel(), true);
299   }
300
301   public void applyEditorTo(@NotNull final JUnitConfiguration configuration) {
302     configuration.setRepeatMode((String)myRepeatCb.getSelectedItem());
303     try {
304       configuration.setRepeatCount(Integer.parseInt(myRepeatCountField.getText()));
305     }
306     catch (NumberFormatException e) {
307       configuration.setRepeatCount(1);
308     }
309     myModel.apply(getModuleSelector().getModule(), configuration);
310     configuration.getPersistentData().setUniqueIds(myUniqueIdField.getComponent().getText().split(" "));
311     configuration.getPersistentData().setChangeList((String)myChangeListLabeledComponent.getComponent().getSelectedItem());
312     applyHelpersTo(configuration);
313     final JUnitConfiguration.Data data = configuration.getPersistentData();
314     if (myWholeProjectScope.isSelected()) {
315       data.setScope(TestSearchScope.WHOLE_PROJECT);
316     }
317     else if (mySingleModuleScope.isSelected()) {
318       data.setScope(TestSearchScope.SINGLE_MODULE);
319     }
320     else if (myModuleWDScope.isSelected()) {
321       data.setScope(TestSearchScope.MODULE_WITH_DEPENDENCIES);
322     }
323     configuration.setAlternativeJrePath(myJrePathEditor.getJrePathOrName());
324     configuration.setAlternativeJrePathEnabled(myJrePathEditor.isAlternativeJreSelected());
325
326     myCommonJavaParameters.applyTo(configuration);
327     configuration.setForkMode((String)myForkCb.getSelectedItem());
328     configuration.setShortenCommandLine((ShortenCommandLine)myShortenClasspathModeCombo.getComponent().getSelectedItem());
329   }
330
331   public void resetEditorFrom(@NotNull final JUnitConfiguration configuration) {
332     final int count = configuration.getRepeatCount();
333     myRepeatCountField.setText(String.valueOf(count));
334     myRepeatCountField.setEnabled(count > 1);
335     myRepeatCb.setSelectedItem(configuration.getRepeatMode());
336
337     myModel.reset(configuration);
338     myChangeListLabeledComponent.getComponent().setSelectedItem(configuration.getPersistentData().getChangeList());
339     String[] ids = configuration.getPersistentData().getUniqueIds();
340     myUniqueIdField.getComponent().setText(ids != null ? StringUtil.join(ids, " ") : null);
341     myCommonJavaParameters.reset(configuration);
342     getModuleSelector().reset(configuration);
343     final TestSearchScope scope = configuration.getPersistentData().getScope();
344     if (scope == TestSearchScope.SINGLE_MODULE) {
345       mySingleModuleScope.setSelected(true);
346     }
347     else if (scope == TestSearchScope.MODULE_WITH_DEPENDENCIES) {
348       myModuleWDScope.setSelected(true);
349     }
350     else {
351       myWholeProjectScope.setSelected(true);
352     }
353     myJrePathEditor
354       .setPathOrName(configuration.getAlternativeJrePath(), configuration.isAlternativeJrePathEnabled());
355     myForkCb.setSelectedItem(configuration.getForkMode());
356     myShortenClasspathModeCombo.getComponent().setSelectedItem(configuration.getShortenCommandLine());
357   }
358
359   private void changePanel () {
360     String selectedItem = (String)myForkCb.getSelectedItem();
361     if (selectedItem == null) {
362       selectedItem = JUnitConfiguration.FORK_NONE;
363     }
364     final Integer selectedType = (Integer)myTypeChooser.getSelectedItem();
365     if (selectedType == JUnitConfigurationModel.ALL_IN_PACKAGE) {
366       myPackagePanel.setVisible(true);
367       myScopesPanel.setVisible(true);
368       myPattern.setVisible(false);
369       myClass.setVisible(false);
370       myCategory.setVisible(false);
371       myUniqueIdField.setVisible(false);
372       myMethod.setVisible(false);
373       myDir.setVisible(false);
374       myChangeListLabeledComponent.setVisible(false);
375       myForkCb.setEnabled(true);
376       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
377       myForkCb.setSelectedItem(selectedItem);
378     } else if (selectedType == JUnitConfigurationModel.DIR) {
379       myPackagePanel.setVisible(false);
380       myScopesPanel.setVisible(false);
381       myDir.setVisible(true);
382       myPattern.setVisible(false);
383       myClass.setVisible(false);
384       myCategory.setVisible(false);
385       myUniqueIdField.setVisible(false);
386       myChangeListLabeledComponent.setVisible(false);
387       myMethod.setVisible(false);
388       myForkCb.setEnabled(true);
389       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
390       myForkCb.setSelectedItem(selectedItem);
391     }
392     else if (selectedType == JUnitConfigurationModel.CLASS) {
393       myPackagePanel.setVisible(false);
394       myScopesPanel.setVisible(false);
395       myPattern.setVisible(false);
396       myDir.setVisible(false);
397       myClass.setVisible(true);
398       myCategory.setVisible(false);
399       myUniqueIdField.setVisible(false);
400       myChangeListLabeledComponent.setVisible(false);
401       myMethod.setVisible(false);
402       myForkCb.setEnabled(true);
403       myForkCb.setModel(getForkModelBasedOnRepeat());
404       myForkCb.setSelectedItem(selectedItem != JUnitConfiguration.FORK_KLASS ? selectedItem : JUnitConfiguration.FORK_METHOD);
405     }
406     else if (selectedType == JUnitConfigurationModel.METHOD || selectedType == JUnitConfigurationModel.BY_SOURCE_POSITION){
407       myPackagePanel.setVisible(false);
408       myScopesPanel.setVisible(false);
409       myPattern.setVisible(false);
410       myDir.setVisible(false);
411       myClass.setVisible(true);
412       myCategory.setVisible(false);
413       myUniqueIdField.setVisible(false);
414       myMethod.setVisible(true);
415       myChangeListLabeledComponent.setVisible(false);
416       myForkCb.setEnabled(false);
417       myForkCb.setSelectedItem(JUnitConfiguration.FORK_NONE);
418     } else if (selectedType == JUnitConfigurationModel.CATEGORY) {
419       myPackagePanel.setVisible(false);
420       myScopesPanel.setVisible(true);
421       myDir.setVisible(false);
422       myPattern.setVisible(false);
423       myClass.setVisible(false);
424       myCategory.setVisible(true);
425       myUniqueIdField.setVisible(false);
426       myMethod.setVisible(false);
427       myChangeListLabeledComponent.setVisible(false);
428       myForkCb.setEnabled(true);
429       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
430       myForkCb.setSelectedItem(selectedItem);
431     }
432     else if (selectedType == JUnitConfigurationModel.BY_SOURCE_CHANGES) {
433       myPackagePanel.setVisible(false);
434       myScopesPanel.setVisible(false);
435       myDir.setVisible(false);
436       myPattern.setVisible(false);
437       myClass.setVisible(false);
438       myCategory.setVisible(false);
439       myUniqueIdField.setVisible(false);
440       myMethod.setVisible(false);
441       myChangeListLabeledComponent.setVisible(true);
442       myForkCb.setEnabled(true);
443       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
444       myForkCb.setSelectedItem(selectedItem);
445     }
446     else if (selectedType == JUnitConfigurationModel.UNIQUE_ID) {
447       myPackagePanel.setVisible(false);
448       myScopesPanel.setVisible(false);
449       myDir.setVisible(false);
450       myPattern.setVisible(false);
451       myClass.setVisible(false);
452       myCategory.setVisible(false);
453       myUniqueIdField.setVisible(true);
454       myMethod.setVisible(false);
455       myChangeListLabeledComponent.setVisible(false);
456       myForkCb.setEnabled(true);
457       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
458       myForkCb.setSelectedItem(selectedItem);
459     }
460     else {
461       myPackagePanel.setVisible(false);
462       myScopesPanel.setVisible(true);
463       myPattern.setVisible(true);
464       myDir.setVisible(false);
465       myClass.setVisible(false);
466       myCategory.setVisible(false);
467       myUniqueIdField.setVisible(false);
468       myMethod.setVisible(true);
469       myChangeListLabeledComponent.setVisible(false);
470       myForkCb.setEnabled(true);
471       myForkCb.setModel(new DefaultComboBoxModel(FORK_MODE_ALL));
472       myForkCb.setSelectedItem(selectedItem);
473     }
474   }
475
476   private DefaultComboBoxModel getForkModelBasedOnRepeat() {
477     return new DefaultComboBoxModel(RepeatCount.ONCE.equals(myRepeatCb.getSelectedItem()) ? FORK_MODE : FORK_MODE_ALL);
478   }
479
480   public ModuleDescriptionsComboBox getModulesComponent() {
481     return myModule.getComponent();
482   }
483
484   public ConfigurationModuleSelector getModuleSelector() {
485     return myModuleSelector;
486   }
487
488   private void installDocuments() {
489     for (int i = 0; i < myTestLocations.length; i++) {
490       final LabeledComponent testLocation = getTestLocation(i);
491       final JComponent component = testLocation.getComponent();
492       final ComponentWithBrowseButton field;
493       Object document;
494       if (component instanceof TextFieldWithBrowseButton) {
495         field = (TextFieldWithBrowseButton)component;
496         document = new PlainDocument();
497         ((TextFieldWithBrowseButton)field).getTextField().setDocument((Document)document);
498       } else if (component instanceof EditorTextFieldWithBrowseButton) {
499         field = (ComponentWithBrowseButton)component;
500         document = ((EditorTextField)field.getChildComponent()).getDocument();
501       }
502       else {
503         field = myPatternTextField;
504         document = new PlainDocument();
505         ((TextFieldWithBrowseButton)field).getTextField().setDocument((Document)document);
506         
507       }
508       myBrowsers[i].setField(field);
509       if (myBrowsers[i] instanceof MethodBrowser) {
510         final EditorTextField childComponent = (EditorTextField)field.getChildComponent();
511         ((MethodBrowser)myBrowsers[i]).installCompletion(childComponent);
512         document = childComponent.getDocument();
513       }
514       myModel.setJUnitDocument(i, document);
515     }
516   }
517
518   public LabeledComponent getTestLocation(final int index) {
519     return myTestLocations[index];
520   }
521
522   private void createUIComponents() {
523     myPackage = new LabeledComponent<>();
524     myPackage.setComponent(new EditorTextFieldWithBrowseButton(myProject, false));
525
526     myClass = new LabeledComponent<>();
527     final TestClassBrowser classBrowser = new TestClassBrowser(myProject);
528     myClass.setComponent(new EditorTextFieldWithBrowseButton(myProject, true, new JavaCodeFragment.VisibilityChecker() {
529       @Override
530       public Visibility isDeclarationVisible(PsiElement declaration, PsiElement place) {
531         try {
532           if (declaration instanceof PsiClass && (classBrowser.getFilter().isAccepted(((PsiClass)declaration)) || classBrowser.findClass(((PsiClass)declaration).getQualifiedName()) != null && place.getParent() != null)) {
533             return Visibility.VISIBLE;
534           }
535         }
536         catch (ClassBrowser.NoFilterException e) {
537           return Visibility.NOT_VISIBLE;
538         }
539         return Visibility.NOT_VISIBLE;
540       }
541     }));
542
543     myCategory = new LabeledComponent<>();
544     myCategory.setComponent(new EditorTextFieldWithBrowseButton(myProject, true, new JavaCodeFragment.VisibilityChecker() {
545       @Override
546       public Visibility isDeclarationVisible(PsiElement declaration, PsiElement place) {
547         if (declaration instanceof PsiClass) {
548           return Visibility.VISIBLE;
549         }
550         return Visibility.NOT_VISIBLE;
551       }
552     }));
553
554     myMethod = new LabeledComponent<>();
555     final EditorTextFieldWithBrowseButton textFieldWithBrowseButton = new EditorTextFieldWithBrowseButton(myProject, true,
556                                                                                                           JavaCodeFragment.VisibilityChecker.EVERYTHING_VISIBLE,
557                                                                                                           PlainTextLanguage.INSTANCE.getAssociatedFileType());
558     myMethod.setComponent(textFieldWithBrowseButton);
559
560     myShortenClasspathModeCombo = new LabeledComponent<>();
561   }
562
563   @Override
564   public JComponent getAnchor() {
565     return anchor;
566   }
567
568   @Override
569   public void setAnchor(JComponent anchor) {
570     this.anchor = anchor;
571     mySearchForTestsLabel.setAnchor(anchor);
572     myTestLabel.setAnchor(anchor);
573     myClass.setAnchor(anchor);
574     myDir.setAnchor(anchor);
575     myMethod.setAnchor(anchor);
576     myPattern.setAnchor(anchor);
577     myPackage.setAnchor(anchor);
578     myCategory.setAnchor(anchor);
579     myUniqueIdField.setAnchor(anchor);
580     myChangeListLabeledComponent.setAnchor(anchor);
581   }
582
583   public void onTypeChanged(final int newType) {
584     myTypeChooser.setSelectedItem(newType);
585     final TIntArrayList enabledFields = ourEnabledFields.get(newType);
586     for (int i = 0; i < myTestLocations.length; i++)
587       getTestLocation(i).setEnabled(enabledFields.contains(i));
588     /*if (newType == JUnitConfigurationModel.PATTERN) {
589       myModule.setEnabled(false);
590     } else */if (newType != JUnitConfigurationModel.ALL_IN_PACKAGE &&
591                  newType != JUnitConfigurationModel.PATTERN &&
592                  newType != JUnitConfigurationModel.CATEGORY &&
593                  newType != JUnitConfigurationModel.UNIQUE_ID) {
594       myModule.setEnabled(true);
595     }
596     else {
597       onScopeChanged();
598     }
599   }
600
601   private void onScopeChanged() {
602     final Integer selectedItem = (Integer)myTypeChooser.getSelectedItem();
603     final boolean allInPackageAllInProject = (selectedItem == JUnitConfigurationModel.ALL_IN_PACKAGE ||
604                                               selectedItem == JUnitConfigurationModel.PATTERN ||
605                                               selectedItem == JUnitConfigurationModel.CATEGORY ||
606                                               selectedItem == JUnitConfigurationModel.UNIQUE_ID ) && myWholeProjectScope.isSelected();
607     myModule.setEnabled(!allInPackageAllInProject);
608     if (allInPackageAllInProject) {
609       myModule.getComponent().setSelectedItem(null);
610     }
611   }
612
613   private String getClassName() {
614     return ((LabeledComponent<EditorTextFieldWithBrowseButton>)getTestLocation(JUnitConfigurationModel.CLASS)).getComponent().getText();
615   }
616
617   private void setPackage(final PsiPackage aPackage) {
618     if (aPackage == null) return;
619     ((LabeledComponent<EditorTextFieldWithBrowseButton>)getTestLocation(JUnitConfigurationModel.ALL_IN_PACKAGE)).getComponent()
620       .setText(aPackage.getQualifiedName());
621   }
622
623   @NotNull
624   public JComponent createEditor() {
625     return myWholePanel;
626   }
627
628   private void applyHelpersTo(final JUnitConfiguration currentState) {
629     myCommonJavaParameters.applyTo(currentState);
630     getModuleSelector().applyTo(currentState);
631   }
632
633   private static class PackageChooserActionListener extends BrowseModuleValueActionListener {
634     public PackageChooserActionListener(final Project project) {
635       super(project);
636     }
637
638     protected String showDialog() {
639       final PackageChooserDialog dialog = new PackageChooserDialog(ExecutionBundle.message("choose.package.dialog.title"), getProject());
640       dialog.show();
641       final PsiPackage aPackage = dialog.getSelectedPackage();
642       return aPackage != null ? aPackage.getQualifiedName() : null;
643     }
644   }
645
646   private class TestsChooserActionListener extends TestClassBrowser {
647     public TestsChooserActionListener(final Project project) {
648       super(project);
649     }
650
651     @Override
652     protected void onClassChoosen(PsiClass psiClass) {
653       final JTextField textField = myPatternTextField.getTextField();
654       final String text = textField.getText();
655       textField.setText(text + (text.length() > 0 ? "||" : "") + psiClass.getQualifiedName());
656     }
657
658     @Override
659     protected ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException {
660       try {
661         return TestClassFilter.create(SourceScope.wholeProject(getProject()), null);
662       }
663       catch (JUnitUtil.NoJUnitException ignore) {
664         throw new NoFilterException(new MessagesEx.MessageInfo(getProject(),
665                                                                ignore.getMessage(),
666                                                                ExecutionBundle.message("cannot.browse.test.inheritors.dialog.title")));
667       }
668     }
669
670     @Override
671     public void actionPerformed(ActionEvent e) {
672       showDialog();
673     }
674   }
675
676   private class TestClassBrowser extends ClassBrowser {
677     public TestClassBrowser(final Project project) {
678       super(project, ExecutionBundle.message("choose.test.class.dialog.title"));
679     }
680
681     protected void onClassChoosen(final PsiClass psiClass) {
682       setPackage(JUnitUtil.getContainingPackage(psiClass));
683     }
684
685     protected PsiClass findClass(final String className) {
686       return getModuleSelector().findClass(className);
687     }
688
689     protected ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException {
690       final ConfigurationModuleSelector moduleSelector = getModuleSelector();
691       final Module module = moduleSelector.getModule();
692       if (module == null) {
693         throw NoFilterException.moduleDoesntExist(moduleSelector);
694       }
695       final ClassFilter.ClassFilterWithScope classFilter;
696       try {
697         final JUnitConfiguration configurationCopy =
698           new JUnitConfiguration(ExecutionBundle.message("default.junit.configuration.name"), getProject(),
699                                  JUnitConfigurationType.getInstance().getConfigurationFactories()[0]);
700         applyEditorTo(configurationCopy);
701         classFilter = TestClassFilter
702           .create(SourceScope.modulesWithDependencies(configurationCopy.getModules()), configurationCopy.getConfigurationModule().getModule());
703       }
704       catch (JUnitUtil.NoJUnitException e) {
705         throw NoFilterException.noJUnitInModule(module);
706       }
707       return classFilter;
708     }
709   }
710
711   private class CategoryBrowser extends ClassBrowser {
712     public CategoryBrowser(Project project) {
713       super(project, "Category Interface");
714     }
715
716     protected PsiClass findClass(final String className) {
717       return myModuleSelector.findClass(className);
718     }
719
720     protected ClassFilter.ClassFilterWithScope getFilter() throws NoFilterException {
721       final Module module = myModuleSelector.getModule();
722       final GlobalSearchScope scope;
723       if (module == null) {
724         scope = GlobalSearchScope.allScope(myProject);
725       }
726       else {
727         scope = GlobalSearchScope.moduleWithDependenciesAndLibrariesScope(module);
728       }
729       return new ClassFilter.ClassFilterWithScope() {
730         public GlobalSearchScope getScope() {
731           return scope;
732         }
733
734         public boolean isAccepted(final PsiClass aClass) {
735           return true;
736         }
737       };
738     }
739
740     @Override
741     protected void onClassChoosen(PsiClass psiClass) {
742       ((LabeledComponent<EditorTextFieldWithBrowseButton>)getTestLocation(JUnitConfigurationModel.CATEGORY)).getComponent()
743         .setText(psiClass.getQualifiedName());
744     }
745   }
746 }