b07f6e302fcee060e9fd388c45968179cbeec02c
[idea/community.git] / plugins / junit / src / com / intellij / execution / junit2 / configuration / JUnitConfigurationModel.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.execution.JavaExecutionUtil;
20 import com.intellij.execution.junit.JUnitConfiguration;
21 import com.intellij.execution.junit.JUnitUtil;
22 import com.intellij.openapi.command.WriteCommandAction;
23 import com.intellij.openapi.editor.Document;
24 import com.intellij.openapi.module.Module;
25 import com.intellij.openapi.progress.ProcessCanceledException;
26 import com.intellij.openapi.project.IndexNotReadyException;
27 import com.intellij.openapi.project.Project;
28 import com.intellij.openapi.util.text.StringUtil;
29 import com.intellij.psi.PsiClass;
30
31 import javax.swing.text.BadLocationException;
32 import javax.swing.text.PlainDocument;
33 import java.util.Arrays;
34 import java.util.LinkedHashSet;
35 import java.util.List;
36
37 // Author: dyoma
38
39 public class JUnitConfigurationModel {
40   public static final int ALL_IN_PACKAGE = 0;
41   public static final int CLASS = 1;
42   public static final int METHOD = 2;
43   public static final int PATTERN = 3;
44   public static final int DIR = 4;
45   public static final int CATEGORY = 5;
46   public static final int UNIQUE_ID = 6;
47   public static final int BY_SOURCE_POSITION = 7;
48   public static final int BY_SOURCE_CHANGES = 8;
49
50   private static final List<String> ourTestObjects;
51
52   static {
53     ourTestObjects = Arrays.asList(JUnitConfiguration.TEST_PACKAGE,
54                                    JUnitConfiguration.TEST_CLASS, 
55                                    JUnitConfiguration.TEST_METHOD,
56                                    JUnitConfiguration.TEST_PATTERN,
57                                    JUnitConfiguration.TEST_DIRECTORY,
58                                    JUnitConfiguration.TEST_CATEGORY,
59                                    JUnitConfiguration.TEST_UNIQUE_ID,
60                                    JUnitConfiguration.BY_SOURCE_POSITION,
61                                    JUnitConfiguration.BY_SOURCE_CHANGES);
62   }
63
64
65   private JUnitConfigurable myListener;
66   private int myType = -1;
67   private final Object[] myJUnitDocuments = new Object[6];
68   private final Project myProject;
69
70   public JUnitConfigurationModel(final Project project) {
71     myProject = project;
72   }
73
74   public boolean setType(int type) {
75     if (type == myType) return false;
76     if (type < 0 || type >= ourTestObjects.size()) type = CLASS;
77     myType = type;
78     fireTypeChanged(type);
79     return true;
80   }
81
82   private void fireTypeChanged(final int newType) {
83     myListener.onTypeChanged(newType);
84   }
85
86   public void setListener(final JUnitConfigurable listener) {
87     myListener = listener;
88   }
89
90   public Object getJUnitDocument(final int i) {
91     return myJUnitDocuments[i];
92   }
93
94   public void setJUnitDocument(final int i, Object doc) {
95      myJUnitDocuments[i] = doc;
96   }
97
98   public void apply(final Module module, final JUnitConfiguration configuration) {
99     final boolean shouldUpdateName = configuration.isGeneratedName();
100     applyTo(configuration.getPersistentData(), module);
101     if (shouldUpdateName && !JavaExecutionUtil.isNewName(configuration.getName())) {
102       configuration.setGeneratedName();
103     }
104   }
105
106   private void applyTo(final JUnitConfiguration.Data data, final Module module) {
107     final String testObject = getTestObject();
108     final String className = getJUnitTextValue(CLASS);
109     data.TEST_OBJECT = testObject;
110     if (testObject != JUnitConfiguration.TEST_PACKAGE &&
111         testObject != JUnitConfiguration.TEST_PATTERN &&
112         testObject != JUnitConfiguration.TEST_DIRECTORY &&
113         testObject != JUnitConfiguration.TEST_CATEGORY  &&
114         testObject != JUnitConfiguration.BY_SOURCE_CHANGES) {
115       try {
116         data.METHOD_NAME = getJUnitTextValue(METHOD);
117         final PsiClass testClass = !myProject.isDefault() && !StringUtil.isEmptyOrSpaces(className) ? JUnitUtil.findPsiClass(className, module, myProject) : null;
118         if (testClass != null && testClass.isValid()) {
119           data.setMainClass(testClass);
120         }
121         else {
122           data.MAIN_CLASS_NAME = className;
123         }
124       }
125       catch (ProcessCanceledException | IndexNotReadyException e) {
126         data.MAIN_CLASS_NAME = className;
127       }
128     }
129     else if (testObject != JUnitConfiguration.BY_SOURCE_CHANGES) {
130       if (testObject == JUnitConfiguration.TEST_PACKAGE) {
131         data.PACKAGE_NAME = getJUnitTextValue(ALL_IN_PACKAGE);
132       }
133       else if (testObject == JUnitConfiguration.TEST_DIRECTORY) {
134         data.setDirName(getJUnitTextValue(DIR));
135       }
136       else if (testObject == JUnitConfiguration.TEST_CATEGORY) {
137         data.setCategoryName(getJUnitTextValue(CATEGORY));
138       }
139       else {
140         final LinkedHashSet<String> set = new LinkedHashSet<>();
141         final String[] patterns = getJUnitTextValue(PATTERN).split("\\|\\|");
142         for (String pattern : patterns) {
143           if (pattern.length() > 0) {
144             set.add(pattern);
145           }
146         }
147         data.setPatterns(set);
148       }
149       data.MAIN_CLASS_NAME = "";
150       data.METHOD_NAME = "";
151     }
152   }
153
154   private String getTestObject() {
155     return ourTestObjects.get(myType);
156   }
157
158   private String getJUnitTextValue(final int index) {
159     return getDocumentText(index, myJUnitDocuments);
160   }
161
162   private static String getDocumentText(final int index, final Object[] documents) {
163     final Object document = documents[index];
164     if (document instanceof PlainDocument) {
165       try {
166         return ((PlainDocument)document).getText(0, ((PlainDocument)document).getLength());
167       }
168       catch (BadLocationException e) {
169         throw new RuntimeException(e);
170       }
171     }
172     return ((Document)document).getText();
173   }
174
175   public void reset(final JUnitConfiguration configuration) {
176     final JUnitConfiguration.Data data = configuration.getPersistentData();
177     setTestType(data.TEST_OBJECT);
178     setJUnitTextValue(ALL_IN_PACKAGE, data.getPackageName());
179     setJUnitTextValue(CLASS, data.getMainClassName() != null ? data.getMainClassName().replaceAll("\\$", "\\.") : "");
180     setJUnitTextValue(METHOD, data.getMethodNameWithSignature());
181     setJUnitTextValue(PATTERN, data.getPatternPresentation());
182     setJUnitTextValue(DIR, data.getDirName());
183     setJUnitTextValue(CATEGORY, data.getCategory());
184   }
185
186   private void setJUnitTextValue(final int index, final String text) {
187     setDocumentText(index, text, myJUnitDocuments);
188   }
189
190   private void setDocumentText(final int index, final String text, final Object[] documents) {
191     final Object document = documents[index];
192     if (document instanceof PlainDocument) {
193       try {
194         ((PlainDocument)document).remove(0, ((PlainDocument)document).getLength());
195         ((PlainDocument)document).insertString(0, text, null);
196       }
197       catch (BadLocationException e) {
198         throw new RuntimeException(e);
199       }
200     }
201     else {
202       WriteCommandAction.runWriteCommandAction(myProject, () -> ((Document)document).replaceString(0, ((Document)document).getTextLength(), text));
203     }
204   }
205
206   private void setTestType(final String testObject) {
207     setType(ourTestObjects.indexOf(testObject));
208   }
209 }
210