Unnamed: 0
int64 0
305k
| body
stringlengths 7
52.9k
| name
stringlengths 1
185
|
|---|---|---|
17,600
|
void (@Nullable String value) { VM_PARAMETERS = StringUtil.nullize(value); }
|
setVMParameters
|
17,601
|
String () { return VM_PARAMETERS; }
|
getVMParameters
|
17,602
|
void (String value) { PARAMETERS = value; }
|
setProgramParameters
|
17,603
|
String () { return PARAMETERS; }
|
getProgramParameters
|
17,604
|
void (String value) { WORKING_DIRECTORY = StringUtil.isEmptyOrSpaces(value) ? "" : FileUtilRt.toSystemIndependentName(value.trim()); }
|
setWorkingDirectory
|
17,605
|
String () { return ExternalizablePath.localPathValue(WORKING_DIRECTORY); }
|
getWorkingDirectory
|
17,606
|
boolean (Object obj) { if (!(obj instanceof TestData data)) { return false; } else { return Objects.equals(TEST_OBJECT, data.TEST_OBJECT) && Objects.equals(getMainClassName(), data.getMainClassName()) && Objects.equals(getPackageName(), data.getPackageName()) && Objects.equals(getSuiteName(), data.getSuiteName()) && Objects.equals(getMethodName(), data.getMethodName()) && Objects.equals(WORKING_DIRECTORY, data.WORKING_DIRECTORY) && Objects.equals(OUTPUT_DIRECTORY, data.OUTPUT_DIRECTORY) && Objects.equals(VM_PARAMETERS, data.VM_PARAMETERS) && Objects.equals(PARAMETERS, data.PARAMETERS) && Comparing.equal(myPatterns, data.myPatterns) && USE_DEFAULT_REPORTERS == data.USE_DEFAULT_REPORTERS; } }
|
equals
|
17,607
|
int () { return Comparing.hashcode(getMainClassName()) ^ Comparing.hashcode(getMethodName()) ^ Comparing.hashcode(getGroupName()) ^ Comparing.hashcode(getSuiteName()) ^ Comparing.hashcode(TEST_OBJECT) ^ Comparing.hashcode(WORKING_DIRECTORY) ^ Comparing.hashcode(OUTPUT_DIRECTORY) ^ Comparing.hashcode(VM_PARAMETERS) ^ Comparing.hashcode(PARAMETERS) ^ Comparing.hashcode(USE_DEFAULT_REPORTERS) ^ Comparing.hashcode(myPatterns); }
|
hashCode
|
17,608
|
TestData () { TestData data; try { data = (TestData)super.clone(); } catch (CloneNotSupportedException e) { //can't happen right? //noinspection CallToPrintStackTrace e.printStackTrace(); data = new TestData(); } data.TEST_SEARCH_SCOPE = new TestSearchScope.Wrapper(); data.TEST_PROPERTIES = new HashMap<>(); data.TEST_PROPERTIES.putAll(TEST_PROPERTIES); data.TEST_LISTENERS = new ArrayList<>(); data.TEST_LISTENERS.addAll(TEST_LISTENERS); data.USE_DEFAULT_REPORTERS = USE_DEFAULT_REPORTERS; data.ENVS = new LinkedHashMap<>(ENVS); data.myPatterns = new LinkedHashSet<>(); data.myPatterns.addAll(myPatterns); data.setScope(getScope()); return data; }
|
clone
|
17,609
|
String () { return MAIN_CLASS_NAME == null ? "" : MAIN_CLASS_NAME; }
|
getMainClassName
|
17,610
|
Module (Location<PsiMethod> location) { final PsiMethod method = location.getPsiElement(); METHOD_NAME = method.getName(); TEST_OBJECT = TestType.METHOD.getType(); return setMainClass(location instanceof MethodLocation ? ((MethodLocation)location).getContainingClass() : method.getContainingClass()); }
|
setTestMethod
|
17,611
|
Module (PsiPackage pkg) { PACKAGE_NAME = pkg.getQualifiedName(); return null; }
|
setPackage
|
17,612
|
Module (PsiClass psiclass) { MAIN_CLASS_NAME = JavaExecutionUtil.getRuntimeQualifiedName(psiclass); PACKAGE_NAME = StringUtil.getPackageName(Objects.requireNonNull(psiclass.getQualifiedName())); return JavaExecutionUtil.findModule(psiclass); }
|
setMainClass
|
17,613
|
void (final Map<String, String> envs) { ENVS = envs; }
|
setEnvs
|
17,614
|
Set<String> () { return myPatterns; }
|
getPatterns
|
17,615
|
void (LinkedHashSet<String> set) { myPatterns = set; }
|
setPatterns
|
17,616
|
String () { return myChangeList; }
|
getChangeList
|
17,617
|
void (String changeList) { myChangeList = changeList; }
|
setChangeList
|
17,618
|
String () { return JavaExecutionUtil.getPresentableClassName(myConfig.getPersistantData().getMainClassName()); }
|
getGeneratedName
|
17,619
|
String () { return JavaExecutionUtil.getShortClassName(myConfig.getPersistantData().MAIN_CLASS_NAME); }
|
getActionName
|
17,620
|
boolean (PsiElement element) { element = PsiTreeUtil.getParentOfType(element, PsiModifierListOwner.class, false); if (element instanceof PsiClass) { return Comparing.strEqual(myConfig.getPersistantData().getMainClassName(), JavaExecutionUtil.getRuntimeQualifiedName((PsiClass) element)); } return false; }
|
isConfiguredByElement
|
17,621
|
String () { final TestData data = myConfig.getPersistantData(); return JavaExecutionUtil.getPresentableClassName(data.getMainClassName()) + '.' + data.getMethodName(); }
|
getGeneratedName
|
17,622
|
String () { return myConfig.getPersistantData().getMethodName() + "()"; }
|
getActionName
|
17,623
|
boolean (PsiElement element) { element = PsiTreeUtil.getParentOfType(element, PsiModifierListOwner.class, false); if (element instanceof PsiMethod) { final PsiClass aClass = ((PsiMethod) element).getContainingClass(); final TestData data = myConfig.getPersistantData(); return aClass != null && Comparing.strEqual(data.MAIN_CLASS_NAME, JavaExecutionUtil.getRuntimeQualifiedName(aClass)) && Comparing.strEqual(data.METHOD_NAME, ((PsiMethod) element).getName()); } return false; }
|
isConfiguredByElement
|
17,624
|
boolean (PsiClass psiClass) { if (super.isAccepted(psiClass)) { final String qualifiedName = ReadAction.compute(psiClass::getQualifiedName); LOG.assertTrue(qualifiedName != null); for (Pattern pattern : compilePatterns) { if (pattern.matcher(qualifiedName).matches()) return true; } } return false; }
|
isAccepted
|
17,625
|
String () { final Set<String> patterns = myConfig.getPersistantData().getPatterns(); final int size = patterns.size(); if (size == 0) return TestngBundle.message("action.text.temp.suite"); String firstPattern = ContainerUtil.getFirstItem(patterns); if (size == 1) { return firstPattern; } else { //noinspection DialogTitleCapitalization return TestRunnerBundle.message("test.config.first.pattern.and.few.more", firstPattern, size - 1); } }
|
getGeneratedName
|
17,626
|
String () { return getGeneratedName(); }
|
getActionName
|
17,627
|
String () { final String packageName = myConfig.getPersistantData().getPackageName(); return packageName.isEmpty() ? TestRunnerBundle.message("default.package.presentable.name") : packageName; }
|
getGeneratedName
|
17,628
|
String () { String s = myConfig.getName(); if (!myConfig.isGeneratedName()) return '\"' + s + '\"'; if (!myConfig.getPersistantData().getPackageName().trim().isEmpty()) { return TestngBundle.message("action.text.tests.in.package", myConfig.getPersistantData().getPackageName()); } else { return TestRunnerBundle.message("all.tests.scope.presentable.text"); } }
|
getActionName
|
17,629
|
boolean (PsiElement element) { final String packageName = myConfig.getPersistantData().getPackageName(); if (element instanceof PsiPackage) { return Comparing.strEqual(packageName, ((PsiPackage)element).getQualifiedName()); } else if (element instanceof PsiDirectory) { final PsiPackage psiPackage = JavaDirectoryService.getInstance().getPackage(((PsiDirectory)element)); return psiPackage != null && Comparing.strEqual(packageName, psiPackage.getQualifiedName()); } return false; }
|
isConfiguredByElement
|
17,630
|
boolean (final PsiClass psiClass) { return ReadAction.compute(() -> { if (!ConfigurationUtil.PUBLIC_INSTANTIATABLE_CLASS.value(psiClass)) return false; return TestNGUtil.inheritsITestListener(psiClass); }); }
|
isAccepted
|
17,631
|
Project () { return project; }
|
getProject
|
17,632
|
GlobalSearchScope () { return scope; }
|
getScope
|
17,633
|
String () { return myConfig.getPersistantData().getGroupName(); }
|
getGeneratedName
|
17,634
|
String () { return myConfig.getPersistantData().getGroupName(); }
|
getActionName
|
17,635
|
void (int type, Object doc) { typeDocuments[type] = doc; }
|
setDocument
|
17,636
|
void (TestType type) { this.type = type; updateEditorType(type); }
|
setType
|
17,637
|
void (TestType type) { editor.onTypeChanged(type); }
|
updateEditorType
|
17,638
|
void (TestNGConfigurationEditor editor) { this.editor = editor; }
|
setListener
|
17,639
|
Object (int index) { return typeDocuments[index]; }
|
getDocument
|
17,640
|
Document () { return propertiesFileDocument; }
|
getPropertiesFileDocument
|
17,641
|
Document () { return outputDirectoryDocument; }
|
getOutputDirectoryDocument
|
17,642
|
Project () { return project; }
|
getProject
|
17,643
|
void (Module module, TestNGConfiguration config) { boolean isGenerated = config.isGeneratedName(); apply(config.getPersistantData(), module); if (isGenerated && !JavaExecutionUtil.isNewName(config.getName())) { config.setGeneratedName(); } }
|
apply
|
17,644
|
void (TestData data, Module module) { data.TEST_OBJECT = type.getType(); if (TestType.GROUP == type) { data.GROUP_NAME = getText(TestType.GROUP); data.PACKAGE_NAME = ""; data.MAIN_CLASS_NAME = ""; data.METHOD_NAME = ""; data.SUITE_NAME = ""; } else if (TestType.PACKAGE == type) { data.PACKAGE_NAME = getText(TestType.PACKAGE); data.GROUP_NAME = ""; data.MAIN_CLASS_NAME = ""; data.METHOD_NAME = ""; data.SUITE_NAME = ""; } else if (TestType.METHOD == type || TestType.CLASS == type || TestType.SOURCE == type) { String className = getText(TestType.CLASS); data.GROUP_NAME = ""; data.SUITE_NAME = ""; if (TestType.METHOD == type || TestType.SOURCE == type) data.METHOD_NAME = getText(TestType.METHOD); data.MAIN_CLASS_NAME = className; data.PACKAGE_NAME = StringUtil.getPackageName(className); } else if (TestType.SUITE == type) { data.SUITE_NAME = getText(TestType.SUITE); data.PACKAGE_NAME = ""; data.GROUP_NAME = ""; data.MAIN_CLASS_NAME = ""; data.METHOD_NAME = ""; } else if (TestType.PATTERN == type) { final LinkedHashSet<String> set = new LinkedHashSet<>(); final String[] patterns = getText(TestType.PATTERN).split("\\|\\|"); for (String pattern : patterns) { if (!pattern.isEmpty()) { set.add(pattern); } } data.setPatterns(set); } try { data.PROPERTIES_FILE = propertiesFileDocument.getText(0, propertiesFileDocument.getLength()); } catch (BadLocationException e) { throw new RuntimeException(e); } try { data.OUTPUT_DIRECTORY = outputDirectoryDocument.getText(0, outputDirectoryDocument.getLength()); } catch (BadLocationException e) { throw new RuntimeException(e); } }
|
apply
|
17,645
|
String (TestType type) { return getText(type, typeDocuments); }
|
getText
|
17,646
|
String (TestType testType, Object[] documents) { Object document = documents[testType.getValue()]; if (document instanceof PlainDocument) { try { return ((PlainDocument)document).getText(0, ((PlainDocument)document).getLength()); } catch (BadLocationException e) { throw new RuntimeException(e); } } return ((com.intellij.openapi.editor.Document)document).getText(); }
|
getText
|
17,647
|
void (TestNGConfiguration config) { TestData data = config.getPersistantData(); setType(data.TEST_OBJECT); setTypeValue(TestType.PACKAGE, data.getPackageName()); setTypeValue(TestType.CLASS, data.getMainClassName()); setTypeValue(TestType.METHOD, data.getMethodName()); setTypeValue(TestType.GROUP, data.getGroupName()); setTypeValue(TestType.SUITE, data.getSuiteName()); setTypeValue(TestType.PATTERN, StringUtil.join(data.getPatterns(), "||")); setDocumentText(propertiesFileDocument, data.getPropertiesFile()); setDocumentText(outputDirectoryDocument, data.getOutputDirectory()); }
|
reset
|
17,648
|
void (TestType type, String value) { setTypeValue(type, value, typeDocuments); }
|
setTypeValue
|
17,649
|
void (TestType type, String value, Object[] documents) { Object document = documents[type.getValue()]; setDocumentText(document, value); }
|
setTypeValue
|
17,650
|
void (final Object document, final String value) { if (document instanceof PlainDocument) { try { ((PlainDocument)document).remove(0, ((PlainDocument)document).getLength()); ((PlainDocument)document).insertString(0, value, null); } catch (BadLocationException e) { throw new RuntimeException(e); } } else { WriteCommandAction.runWriteCommandAction(project, () -> ((com.intellij.openapi.editor.Document)document) .replaceString(0, ((com.intellij.openapi.editor.Document)document).getTextLength(), value)); } }
|
setDocumentText
|
17,651
|
void (String s) { try { setType(TestType.valueOf(s)); } catch (IllegalArgumentException e) { LOGGER.debug("Invalid test type of " + s + " found."); setType(TestType.CLASS); } }
|
setType
|
17,652
|
TestNGTestObject (@NotNull TestNGConfiguration config) { final String testObject = config.getPersistantData().TEST_OBJECT; if (testObject.equals(TestType.PACKAGE.getType())) { return new TestNGTestPackage(config); } if (testObject.equals(TestType.CLASS.getType())) { return new TestNGTestClass(config); } if (testObject.equals(TestType.METHOD.getType())) { return new TestNGTestMethod(config); } if (testObject.equals(TestType.GROUP.getType())) { return new TestNGTestGroup(config); } if (testObject.equals(TestType.PATTERN.getType())) { return new TestNGTestPattern(config); } if (testObject.equals(TestType.SUITE.getType())){ return new TestNGTestSuite(config); } if (testObject.equals(TestType.SOURCE.getType())) { return new TestNGSource(config); } LOG.info("Unknown test object" + testObject); return new UnknownTestNGTestObject(config); }
|
fromConfig
|
17,653
|
boolean (PsiElement element) { return false; }
|
isConfiguredByElement
|
17,654
|
void (PsiMethod[] methods, final Map<PsiClass, Map<PsiMethod, List<String>>> results, GlobalSearchScope searchScope, final PsiClass @Nullable ... classes) { calculateDependencies(methods, results, new LinkedHashSet<>(), searchScope, classes); }
|
calculateDependencies
|
17,655
|
void (final PsiMethod[] methods, final Map<PsiClass, Map<PsiMethod, List<String>>> results, final Set<PsiMember> alreadyMarkedToBeChecked, final GlobalSearchScope searchScope, final PsiClass @Nullable ... classes) { if (classes != null && classes.length > 0) { final Set<PsiMember> membersToCheckNow = new LinkedHashSet<>(); final Set<String> groupDependencies = new LinkedHashSet<>(), declaredGroups = new LinkedHashSet<>(); final HashMap<String, Collection<String>> valuesMap = new HashMap<>(); valuesMap.put("dependsOnGroups", groupDependencies); valuesMap.put("groups", declaredGroups); //find all mentioned groups and dependsOnGroup values TestNGUtil.collectAnnotationValues(valuesMap, methods, classes); if (!groupDependencies.isEmpty()) { collectGroupsMembers(TestNGUtil.TEST_ANNOTATION_FQN, groupDependencies, true, results, alreadyMarkedToBeChecked, searchScope, membersToCheckNow, classes); } if (!declaredGroups.isEmpty()) { for (String annotationFqn : GROUPS_CONFIGURATION) { collectGroupsMembers(annotationFqn, declaredGroups, false, results, alreadyMarkedToBeChecked, searchScope, membersToCheckNow, classes); } } collectDependsOnMethods(results, alreadyMarkedToBeChecked, membersToCheckNow, methods, classes); if (methods == null) { for (PsiClass c : classes) { results.put(c, new LinkedHashMap<>()); } } else { for (PsiMember psiMember : membersToCheckNow) { PsiClass psiClass; PsiMethod[] meths = null; if (psiMember instanceof PsiMethod) { psiClass = psiMember.getContainingClass(); meths = new PsiMethod[] {(PsiMethod)psiMember}; } else { psiClass = (PsiClass)psiMember; } calculateDependencies(meths, results, alreadyMarkedToBeChecked, searchScope, psiClass); } } } }
|
calculateDependencies
|
17,656
|
void (final String annotationFqn, final Set<String> groups, final boolean skipUnrelated, final Map<PsiClass, Map<PsiMethod, List<String>>> results, final Set<PsiMember> alreadyMarkedToBeChecked, final GlobalSearchScope searchScope, final Set<PsiMember> membersToCheckNow, final PsiClass... classes) { ApplicationManager.getApplication().runReadAction(() -> { final Project project = classes[0].getProject(); final PsiClass testAnnotation = JavaPsiFacade.getInstance(project).findClass(annotationFqn, GlobalSearchScope.allScope(project)); if (testAnnotation == null) { return; } for (PsiMember psiMember : AnnotatedMembersSearch.search(testAnnotation, searchScope)) { final PsiClass containingClass = psiMember.getContainingClass(); if (containingClass == null) continue; if (skipUnrelated && ArrayUtil.find(classes, containingClass) < 0) continue; final PsiAnnotation annotation = AnnotationUtil.findAnnotation(psiMember, annotationFqn); if (TestNGUtil.isAnnotatedWithParameter(annotation, "groups", groups)) { if (appendMember(psiMember, alreadyMarkedToBeChecked, results)) { membersToCheckNow.add(psiMember); } } } }); }
|
collectGroupsMembers
|
17,657
|
void (final Map<PsiClass, Map<PsiMethod, List<String>>> results, final Set<PsiMember> alreadyMarkedToBeChecked, final Set<PsiMember> membersToCheckNow, final PsiMethod[] methods, final PsiClass... classes) { final PsiClass[] psiClasses; if (methods != null && methods.length > 0) { final Set<PsiClass> containingClasses = new LinkedHashSet<>(); for (final PsiMethod method : methods) { containingClasses.add(ReadAction.compute(() -> method.getContainingClass())); } psiClasses = containingClasses.toArray(PsiClass.EMPTY_ARRAY); } else { psiClasses = classes; } for (final PsiClass containingClass : psiClasses) { final Set<String> testMethodDependencies = new LinkedHashSet<>(); final HashMap<String, Collection<String>> valuesMap = new HashMap<>(); valuesMap.put("dependsOnMethods", testMethodDependencies); TestNGUtil.collectAnnotationValues(valuesMap, methods, containingClass); if (!testMethodDependencies.isEmpty()) { ApplicationManager.getApplication().runReadAction(() -> { final Project project = containingClass.getProject(); final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); for (String dependency : testMethodDependencies) { final String className = StringUtil.getPackageName(dependency); final String methodName = StringUtil.getShortName(dependency); if (StringUtil.isEmpty(className)) { checkClassMethods(methodName, containingClass, alreadyMarkedToBeChecked, membersToCheckNow, results); } else { final PsiClass aClass = psiFacade.findClass(className, containingClass.getResolveScope()); if (aClass != null) { checkClassMethods(methodName, aClass, alreadyMarkedToBeChecked, membersToCheckNow, results); } } } }); } } }
|
collectDependsOnMethods
|
17,658
|
void (String methodName, PsiClass containingClass, Set<PsiMember> alreadyMarkedToBeChecked, Set<PsiMember> membersToCheckNow, Map<PsiClass, Map<PsiMethod, List<String>>> results) { final PsiMethod[] psiMethods = containingClass.findMethodsByName(methodName, true); for (PsiMethod method : psiMethods) { if (AnnotationUtil.isAnnotated(method, TestNGUtil.TEST_ANNOTATION_FQN, 0) && appendMember(method, alreadyMarkedToBeChecked, results)) { membersToCheckNow.add(method); } } }
|
checkClassMethods
|
17,659
|
boolean (final PsiMember psiMember, final Set<PsiMember> underConsideration, final Map<PsiClass, Map<PsiMethod, List<String>>> results) { boolean result = false; final PsiClass psiClass = psiMember instanceof PsiClass ? ((PsiClass)psiMember) : psiMember.getContainingClass(); Map<PsiMethod, List<String>> psiMethods = results.get(psiClass); if (psiMethods == null) { psiMethods = new LinkedHashMap<>(); results.put(psiClass, psiMethods); if (psiMember instanceof PsiClass) { result = underConsideration.add(psiMember); } } if (psiMember instanceof PsiMethod) { final boolean add = psiMethods.put((PsiMethod)psiMember, Collections.emptyList()) != null; if (add) { return underConsideration.add(psiMember); } return false; } return result; }
|
appendMember
|
17,660
|
GlobalSearchScope () { final TestData data = myConfig.getPersistantData(); final Module module = myConfig.getConfigurationModule().getModule(); if (data.TEST_OBJECT.equals(TestType.PACKAGE.getType())) { SourceScope scope = myConfig.getPersistantData().getScope().getSourceScope(myConfig); if (scope != null) { return scope.getGlobalSearchScope(); } } else if (module != null) { return GlobalSearchScope.moduleWithDependenciesScope(module); } return GlobalSearchScope.projectScope(myConfig.getProject()); }
|
getSearchScope
|
17,661
|
void (Map<PsiClass, Map<PsiMethod, List<String>>> classes, final PsiClass psiClass, final String methodName, final GlobalSearchScope searchScope) { final PsiMethod[] methods = ReadAction.compute(() -> psiClass.findMethodsByName(methodName, true)); calculateDependencies(methods, classes, searchScope, psiClass); Map<PsiMethod, List<String>> psiMethods = classes.get(psiClass); if (psiMethods == null) { psiMethods = new LinkedHashMap<>(); classes.put(psiClass, psiMethods); } for (PsiMethod method : methods) { if (!psiMethods.containsKey(method)) { psiMethods.put(method, Collections.emptyList()); } } }
|
collectTestMethods
|
17,662
|
void (Map<PsiClass, Map<PsiMethod, List<String>>> classes) {}
|
fillTestObjects
|
17,663
|
String () { return getActionName(); }
|
getGeneratedName
|
17,664
|
String () { return TestngBundle.message("action.text.unknown.test.object"); }
|
getActionName
|
17,665
|
void () {}
|
checkConfiguration
|
17,666
|
GlobalSearchScope () { final TestNGConfiguration configuration = getConfiguration(); final String testObject = configuration.getPersistantData().TEST_OBJECT; if (TestType.CLASS.getType().equals(testObject) || TestType.METHOD.getType().equals(testObject)) { return super.initScope(); } else { final SourceScope sourceScope = configuration.getPersistantData().getScope().getSourceScope(configuration); return sourceScope != null ? sourceScope.getGlobalSearchScope() : GlobalSearchScope.allScope(getProject()); } }
|
initScope
|
17,667
|
void (DefaultActionGroup actionGroup, JComponent parent, TestConsoleProperties target) { super.appendAdditionalActions(actionGroup, parent, target); actionGroup.add(createIncludeNonStartedInRerun(target)); actionGroup.add(Separator.getInstance()); actionGroup.add(createHideSuccessfulConfig(target)); }
|
appendAdditionalActions
|
17,668
|
SMTestLocator () { return JavaTestLocator.INSTANCE; }
|
getTestLocator
|
17,669
|
AbstractRerunFailedTestsAction (ConsoleView consoleView) { return new RerunFailedTestsAction(consoleView, this); }
|
createRerunFailedTestsAction
|
17,670
|
TestClassFilter (GlobalSearchScope scope) { return new TestClassFilter(this.scope.intersectWith(scope), project, includeConfig, checkClassCanBeInstantiated); }
|
intersectionWith
|
17,671
|
boolean (final PsiClass psiClass) { return ReadAction.compute(() -> { if (!ConfigurationUtil.PUBLIC_INSTANTIATABLE_CLASS.value(psiClass)) return false; //PsiManager manager = PsiManager.getInstance(project); //if(manager.getEffectiveLanguageLevel().compareTo(LanguageLevel.JDK_1_5) < 0) return true; boolean hasTest = TestNGUtil.hasTest(psiClass); if (hasTest) { if (checkClassCanBeInstantiated) { final PsiMethod[] constructors = psiClass.getConstructors(); if (constructors.length > 0) { boolean canBeInstantiated = false; for (PsiMethod constructor : constructors) { PsiParameter[] parameters = constructor.getParameterList().getParameters(); if (parameters.length == 0 || AnnotationUtil.isAnnotated(constructor, INJECTION_ANNOTATIONS, AnnotationUtil.CHECK_HIERARCHY) || parameters.length == 1 && parameters[0].getType().equalsToText(CommonClassNames.JAVA_LANG_STRING)) { canBeInstantiated = true; break; } } if (!canBeInstantiated && !AnnotationUtil.isAnnotated(psiClass, GUICE, 0)) { return false; } } } return true; } return includeConfig && TestNGUtil.hasConfig(psiClass, TestNGUtil.CONFIG_ANNOTATIONS_FQN_NO_TEST_LEVEL); }); }
|
isAccepted
|
17,672
|
Project () { return project; }
|
getProject
|
17,673
|
GlobalSearchScope () { return scope; }
|
getScope
|
17,674
|
String () { final TestData data = myConfig.getPersistantData(); return TestngBundle.message("action.text.tests.for", StringUtil.getQualifiedName(data.getMainClassName(), data.getMethodName())); }
|
getGeneratedName
|
17,675
|
String () { return getGeneratedName(); }
|
getActionName
|
17,676
|
String (Map.Entry<String, String> object) { return object.getKey(); }
|
valueOf
|
17,677
|
TableCellEditor (final Map.Entry<String, String> item) { final JTextField textField = new JTextField(); textField.setBorder(BorderFactory.createLineBorder(JBColor.BLACK)); return new DefaultCellEditor(textField); }
|
getEditor
|
17,678
|
String (Map.Entry<String, String> object) { return object.getValue(); }
|
valueOf
|
17,679
|
TableCellEditor (final Map.Entry<String, String> item) { final JTextField textField = new JTextField(); textField.setBorder(BorderFactory.createLineBorder(JBColor.BLACK)); return new DefaultCellEditor(textField); }
|
getEditor
|
17,680
|
boolean (int rowIndex, int columnIndex) { return true; }
|
isCellEditable
|
17,681
|
void (ArrayList<Map.Entry<String, String>> parameterList) { this.parameterList = parameterList; setItems(parameterList); }
|
setParameterList
|
17,682
|
void () { Map<String, String> map = new HashMap<>(); map.put("", ""); parameterList.addAll(map.entrySet()); setParameterList(parameterList); }
|
addParameter
|
17,683
|
void (Object aValue, int rowIndex, int columnIndex) { Map.Entry<String, String> entry = parameterList.get(rowIndex); String key = entry.getKey(); String value = entry.getValue(); switch (columnIndex) { case 0 -> key = (String)aValue; case 1 -> value = (String)aValue; } Map<String, String> map = new HashMap<>(); map.put(key, value); parameterList.set(rowIndex, map.entrySet().iterator().next()); setParameterList(parameterList); }
|
setValueAt
|
17,684
|
void (int rowIndex) { parameterList.remove(rowIndex); setParameterList(parameterList); }
|
removeProperty
|
17,685
|
Icon (@NotNull String path, int cacheKey, int flags) { return IconManager.getInstance().loadRasterizedIcon(path, TestngIcons.class.getClassLoader(), cacheKey, flags); }
|
load
|
17,686
|
void (TestCaseStarted event) { CucumberJvm5SMFormatter.this.handleTestCaseStarted(new CucumberJvm5Adapter.CucumberJvmTestCase(event.getTestCase())); }
|
receive
|
17,687
|
void (TestCaseFinished event) { handleTestCaseFinished(new CucumberJvm5Adapter.CucumberJvmTestCase(event.getTestCase())); }
|
receive
|
17,688
|
void (TestRunFinished event) { CucumberJvm5SMFormatter.this.handleTestRunFinished(); }
|
receive
|
17,689
|
void (WriteEvent event) { CucumberJvm5SMFormatter.this.handleWriteEvent(new CucumberJvmWriteEvent(event.getText())); }
|
receive
|
17,690
|
void (TestStepStarted event) { handleTestStepStarted(new CucumberJvm5Adapter.CucumberJvmTestStep(event.getTestStep())); }
|
receive
|
17,691
|
void (TestStepFinished event) { handleTestStepFinished(new CucumberJvm5Adapter.CucumberJvmTestStepFinishedEvent(event)); }
|
receive
|
17,692
|
void (TestSourceRead event) { CucumberJvm5SMFormatter.this .handleTestSourceRead(new CucumberJvmTestSourceReadEvent(event.getUri().getPath(), event.getSource())); }
|
receive
|
17,693
|
void (EventPublisher publisher) { publisher.registerHandlerFor(TestCaseStarted.class, this.testCaseStartedHandler); publisher.registerHandlerFor(TestCaseFinished.class, this.testCaseFinishedHandler); publisher.registerHandlerFor(TestStepStarted.class, this.testStepStartedHandler); publisher.registerHandlerFor(TestStepFinished.class, this.testStepFinishedHandler); publisher.registerHandlerFor(TestSourceRead.class, this.testSourceReadHandler); publisher.registerHandlerFor(TestRunFinished.class, this.testRunFinishedHandler); publisher.registerHandlerFor(WriteEvent.class, this.writeEventHandler); }
|
setEventPublisher
|
17,694
|
Status () { switch (myRealEvent.getResult().getStatus()) { case PASSED: return Status.PASSED; case PENDING: return Status.PENDING; case SKIPPED: return Status.SKIPPED; default: return Status.FAILED; } }
|
getResult
|
17,695
|
Long () { return myRealEvent.getResult().getDuration() != null ? myRealEvent.getResult().getDuration().toMillis(): 0; }
|
getDuration
|
17,696
|
String () { Throwable error = myRealEvent.getResult().getError(); String result = error != null ? error.getMessage() : null; return result != null ? result : ""; }
|
getErrorMessage
|
17,697
|
boolean () { Pickle pickle = getPickleEvent(myRealTestCase); return pickle != null && pickle.getLocations().size() > 1; }
|
isScenarioOutline
|
17,698
|
String () { return myRealTestCase.getUri().getPath(); }
|
getUri
|
17,699
|
int () { Pickle pickle = getPickleEvent(myRealTestCase); if (pickle != null) { return pickle.getLocations().get(pickle.getLocations().size() - 1).getLine(); } return 0; }
|
getScenarioOutlineLine
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.