| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.netbeans.modules.java.testrunner; |
| |
| import java.lang.ref.Reference; |
| import java.lang.ref.WeakReference; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Utility class providing various parsing routines for parsing JUnit output. |
| * |
| * @author Marian Petras |
| */ |
| public final class JavaRegexpUtils { |
| |
| /** */ |
| public static final String TESTSUITE_PREFIX = "Testsuite: "; //NOI18N |
| /** */ |
| public static final String TESTSUITE_STATS_PREFIX = "Tests run: "; //NOI18N |
| /** */ |
| public static final String FLOAT_NUMBER_REGEX |
| = "[0-9]*(?:\\.[0-9]+)?"; //NOI18N |
| /** */ |
| public static final String SECONDS_REGEX |
| = "s(?:ec(?:ond)?(?:s|\\(s\\))?)?"; //NOI18N |
| /** */ |
| public static final String TESTSUITE_STATS_REGEX |
| = "Tests run: +([0-9]+)," + //NOI18N |
| " +Failures: +([0-9]+), +Errors: +([0-9]+)," + //NOI18N |
| " +Time elapsed: +(.+)" + SECONDS_REGEX; //NOI18N |
| public static final String TESTSUITE_STATS_190_REGEX |
| = "Tests run: +([0-9]+)," + //NOI18N |
| " +Failures: +([0-9]+), +Errors: +([0-9]+)," + //NOI18N |
| "( +Skipped: +([0-9]+),)?" + //NOI18N |
| " +Time elapsed: +(.+)" + SECONDS_REGEX; //NOI18N |
| /** */ |
| public static final String OUTPUT_DELIMITER_PREFIX = "--------"; //NOI18N |
| /** */ |
| public static final String STDOUT_LABEL = "Output"; //NOI18N |
| /** */ |
| public static final String STDERR_LABEL = "Error"; //NOI18N |
| /** */ |
| public static final String OUTPUT_DELIMITER_REGEX |
| = "-{8,} (?:Standard (" //NOI18N |
| + STDOUT_LABEL + '|' + STDERR_LABEL + ")|-{3,}) -{8,}"; //NOI18N |
| /** */ |
| public static final String TESTCASE_PREFIX = "Testcase: "; //NOI18N |
| /** */ |
| public static final String TESTCASE_ISSUE_REGEX |
| = "\\p{Blank}*(?:(FAILED) *|(?i:.*\\berror\\b.*))"; //NOI18N |
| /** */ |
| public static final String TESTCASE_HEADER_PLAIN_REGEX |
| = "\\p{Blank}*(" + JavaRegexpPatterns.JAVA_ID_REGEX + ")\\p{Blank}+took\\p{Blank}+(.+)" + SECONDS_REGEX; //NOI18N |
| /** */ |
| public static final String TESTCASE_HEADER_BRIEF_REGEX |
| = "\\p{Blank}*(" + JavaRegexpPatterns.JAVA_ID_REGEX + ") *\\( *(" + JavaRegexpPatterns.JAVA_ID_REGEX_FULL + ") *\\) *:" + TESTCASE_ISSUE_REGEX; //NOI18N |
| /** */ |
| public static final String TESTCASE_EXCEPTION_REGEX |
| = "((?:" + JavaRegexpPatterns.JAVA_ID_REGEX_FULL + "\\.?(?:Exception|Error|ComparisonFailure))" //NOI18N |
| + "|java\\.lang\\.Throwable)" //NOI18N |
| + "(?: *: *(.*))?"; //NOI18N |
| /** */ |
| public static final String CALLSTACK_LINE_PREFIX = "at "; //NOI18N |
| /** */ |
| public static final String CALLSTACK_LINE_PREFIX_CATCH = "[catch] "; //NOI18N |
| /** */ |
| public static final String CALLSTACK_LINE_REGEX |
| = "(?:\\t\\t?| +| *\\t? *\\[catch\\] )" //NOI18N |
| + CALLSTACK_LINE_PREFIX |
| + "(?:" + JavaRegexpPatterns.JAVA_ID_REGEX_FULL +"/)?" //NOI18N |
| + JavaRegexpPatterns.JAVA_ID_REGEX + "(?:\\." //NOI18N |
| + JavaRegexpPatterns.JAVA_ID_REGEX + ")+" //NOI18N |
| + "(?:\\.<init>)?" //NOI18N |
| + "(?: ?\\([^()]+\\))?"; //NOI18N |
| /** */ |
| public static final String NESTED_EXCEPTION_PREFIX = "Caused by: "; //NOI18N |
| /** */ |
| public static final String NESTED_EXCEPTION_REGEX |
| = "(" + JavaRegexpPatterns.JAVA_ID_REGEX_FULL + ")(?:: (.*))?";//NOI18N |
| public static final String LOCATION_IN_FILE_REGEX |
| = JavaRegexpPatterns.JAVA_ID_REGEX_FULL + "(?:\\:[0-9]+)?"; //NOI18N |
| /** */ |
| public static final String XML_DECL_PREFIX = "<?xml"; //NOI18N |
| /** */ |
| public static final String XML_SPACE_REGEX |
| = "[ \\t\\r\\n]"; //NOI18N |
| /** */ |
| public static final String XML_EQ_REGEX |
| = XML_SPACE_REGEX + '*' + '=' + XML_SPACE_REGEX + '*'; |
| /** */ |
| public static final String XML_ENC_REGEX |
| = "[A-Za-z][-A-Za-z0-9._]*"; //NOI18N |
| /** */ |
| public static final String XML_DECL_REGEX |
| = "\\Q" + XML_DECL_PREFIX + "\\E" //NOI18N |
| + XML_SPACE_REGEX + '+' + "version" //version //NOI18N |
| + XML_EQ_REGEX + "(?:\"1\\.0\"|'1\\.0')" //NOI18N |
| + "(?:" //NOI18N |
| + XML_SPACE_REGEX + '+' + "encoding" //encoding //NOI18N |
| + XML_EQ_REGEX + "(['\"])[A-Za-z][-A-Za-z0-9._]*\\1"//NOI18N |
| + ")?" //NOI18N |
| + "(?:" //NOI18N |
| + XML_SPACE_REGEX + '+' + "standalone" //standalone //NOI18N |
| + XML_EQ_REGEX + "(['\"])(?:yes|no)\\2" //NOI18N |
| + ")?" //NOI18N |
| + XML_SPACE_REGEX + '*' + "\\?>"; //NOI18N |
| |
| /** */ |
| public static final String TEST_LISTENER_PREFIX |
| = "junit.framework.TestListener: "; //NOI18N |
| /** */ |
| public static final String TESTS_COUNT_PREFIX = "tests to run: "; //NOI18N |
| /** */ |
| public static final String START_OF_TEST_PREFIX = "startTest"; //NOI18N |
| /** */ |
| public static final String END_OF_TEST_PREFIX = "endTest"; //NOI18N |
| public static final String ADD_FAILURE_PREFIX = "addFailure"; //NOI18N |
| public static final String ADD_ERROR_PREFIX = "addError"; //NOI18N |
| |
| public static final String COMPARISON_REGEX = |
| ".*expected:<(.*)\\[(.*)\\](.*)> but was:<(.*)\\[(.*)\\](.*)>.*"; //NOI18N |
| public static final String COMPARISON_HIDDEN_REGEX = |
| ".*expected:<(.*)> but was:<(.*)>.*"; //NOI18N |
| |
| /** |
| * Regexp matching part of a Java task's invocation debug message |
| * that specificies the classpath. |
| * Hack to find the classpath an Ant task is using. |
| * Cf. Commandline.describeArguments, issue #28190.<br /> |
| * Captured groups: |
| * <ol> |
| * <li>the classpath |
| * </ol> |
| * <!-- copied from JavaAntLogger --> |
| */ |
| public static final Pattern CLASSPATH_ARGS |
| = Pattern.compile("\r?\n'-classpath'\r?\n'(.*)'\r?\n"); //NOI18N |
| /** |
| * Regexp matching part of a Java task's invocation debug message |
| * that specificies java executable. |
| * Hack to find JDK used for execution. |
| * <!-- copied from JavaAntLogger --> |
| */ |
| public static final Pattern JAVA_EXECUTABLE |
| = Pattern.compile("^Executing '(.*)' with arguments:$", //NOI18N |
| Pattern.MULTILINE); |
| |
| /** */ |
| private static Reference<JavaRegexpUtils> instRef; |
| |
| /** |
| */ |
| public static synchronized JavaRegexpUtils getInstance() { |
| JavaRegexpUtils instance = (instRef != null) ? instRef.get() : null; |
| if (instance == null) { |
| instance = new JavaRegexpUtils(); |
| instRef = new WeakReference<JavaRegexpUtils>(instance); |
| } |
| return instance; |
| } |
| |
| /** Creates a new instance of RegexpUtils */ |
| private JavaRegexpUtils() { } |
| |
| private volatile Pattern fullJavaIdPattern, suiteStatsPattern, suiteStats190Pattern, |
| outputDelimPattern, testcaseIssuePattern, |
| testcaseExceptPattern, callstackLinePattern, |
| nestedExceptPattern, |
| locationInFilePattern, |
| testcaseHeaderBriefPattern, |
| testcaseHeaderPlainPattern, |
| xmlDeclPattern, floatNumPattern, |
| comparisonPattern, comparisonHiddenPattern; |
| |
| //<editor-fold defaultstate="collapsed" desc=" Note about synchronization "> |
| /* |
| * If-blocks in the following methods should be synchronized to ensure that |
| * the patterns are not compiled twice if the methods are called by two or |
| * more threads concurrently. |
| * |
| * But synchronization is quite expensive so I let them unsynchronized. |
| * It may happen that a single pattern is compiled multiple times but |
| * it does not cause any functional problem. I just marked the variables |
| * as 'volatile' so that once the pattern is compiled (and the variable |
| * set), subsequent invocations from other threads will find the actual |
| * non-null value. |
| */ |
| //</editor-fold> |
| |
| /** */ |
| public Pattern getFullJavaIdPattern() { |
| if (fullJavaIdPattern == null) { |
| fullJavaIdPattern |
| = Pattern.compile(JavaRegexpPatterns.JAVA_ID_REGEX_FULL); |
| } |
| return fullJavaIdPattern; |
| } |
| |
| /** */ |
| public Pattern getSuiteStatsPattern() { |
| if (suiteStatsPattern == null) { |
| suiteStatsPattern = Pattern.compile(TESTSUITE_STATS_REGEX); |
| } |
| return suiteStatsPattern; |
| } |
| |
| /** */ |
| public Pattern getSuiteStats190Pattern() { |
| if (suiteStats190Pattern == null) { |
| suiteStats190Pattern = Pattern.compile(TESTSUITE_STATS_190_REGEX); |
| } |
| return suiteStats190Pattern; |
| } |
| |
| /** */ |
| public Pattern getOutputDelimPattern() { |
| if (outputDelimPattern == null) { |
| outputDelimPattern = Pattern.compile(OUTPUT_DELIMITER_REGEX); |
| } |
| return outputDelimPattern; |
| } |
| |
| /** */ |
| public Pattern getTestcaseHeaderBriefPattern() { |
| if (testcaseHeaderBriefPattern == null) { |
| testcaseHeaderBriefPattern = Pattern.compile(TESTCASE_HEADER_BRIEF_REGEX); |
| } |
| return testcaseHeaderBriefPattern; |
| } |
| |
| /** */ |
| public Pattern getTestcaseHeaderPlainPattern() { |
| if (testcaseHeaderPlainPattern == null) { |
| testcaseHeaderPlainPattern = Pattern.compile(TESTCASE_HEADER_PLAIN_REGEX); |
| } |
| return testcaseHeaderPlainPattern; |
| } |
| |
| /** */ |
| public Pattern getTestcaseIssuePattern() { |
| if (testcaseIssuePattern == null) { |
| testcaseIssuePattern = Pattern.compile(TESTCASE_ISSUE_REGEX); |
| } |
| return testcaseIssuePattern; |
| } |
| |
| /** */ |
| public Pattern getTestcaseExceptionPattern() { |
| if (testcaseExceptPattern == null) { |
| testcaseExceptPattern = Pattern.compile(TESTCASE_EXCEPTION_REGEX); |
| } |
| return testcaseExceptPattern; |
| } |
| |
| /** |
| */ |
| public Pattern getNestedExceptionPattern() { |
| if (nestedExceptPattern == null) { |
| nestedExceptPattern = Pattern.compile(NESTED_EXCEPTION_REGEX); |
| } |
| return nestedExceptPattern; |
| } |
| |
| /** */ |
| public Pattern getCallstackLinePattern() { |
| if (callstackLinePattern == null) { |
| callstackLinePattern = Pattern.compile(CALLSTACK_LINE_REGEX); |
| } |
| return callstackLinePattern; |
| } |
| |
| /** */ |
| public Pattern getLocationInFilePattern() { |
| if (locationInFilePattern == null) { |
| locationInFilePattern = Pattern.compile(LOCATION_IN_FILE_REGEX); |
| } |
| return locationInFilePattern; |
| } |
| |
| /** */ |
| public Pattern getXmlDeclPattern() { |
| if (xmlDeclPattern == null) { |
| xmlDeclPattern = Pattern.compile(XML_DECL_REGEX); |
| } |
| return xmlDeclPattern; |
| } |
| |
| /** */ |
| public Pattern getFloatNumPattern() { |
| if (floatNumPattern == null) { |
| floatNumPattern = Pattern.compile(FLOAT_NUMBER_REGEX); |
| } |
| return floatNumPattern; |
| } |
| |
| /** */ |
| public Pattern getComparisonPattern() { |
| if (comparisonPattern == null) { |
| comparisonPattern = Pattern.compile(COMPARISON_REGEX); |
| } |
| return comparisonPattern; |
| } |
| |
| /** */ |
| public Pattern getComparisonHiddenPattern() { |
| if (comparisonHiddenPattern == null) { |
| comparisonHiddenPattern = Pattern.compile(COMPARISON_HIDDEN_REGEX); |
| } |
| return comparisonHiddenPattern; |
| } |
| |
| /** |
| * Parses a floating-point number describing elapsed time. |
| * The returned number is a number of elapsed milliseconds. |
| * |
| * @param string represeting non-negative floating-point number of seconds |
| * @return integer representing number of milliseconds (rounded) |
| * @exception java.lang.NumberFormatException |
| * if the passed string does not match |
| * the {@link #FLOAT_NUMBER_REGEX} pattern |
| */ |
| public int parseTimeMillis(String timeString) throws NumberFormatException { |
| int secs, millis; |
| final int dotIndex = timeString.indexOf('.'); |
| if (dotIndex == -1) { |
| secs = Integer.parseInt(timeString); |
| millis = 0; |
| } else { |
| secs = (dotIndex == 0) |
| ? 0 |
| : Integer.parseInt(timeString.substring(0, dotIndex)); |
| |
| String fractString = timeString.substring(dotIndex + 1); |
| if (fractString.length() > 4) { |
| fractString = fractString.substring(0, 4); |
| } |
| int fractNum = Integer.parseInt(fractString); |
| switch (fractString.length()) { |
| case 1: |
| millis = 100 * fractNum; |
| break; |
| case 2: |
| millis = 10 * fractNum; |
| break; |
| case 3: |
| millis = fractNum; |
| break; |
| case 4: |
| millis = (fractNum + 5) / 10; |
| break; |
| default: |
| assert false; |
| millis = 0; |
| break; |
| } |
| } |
| return 1000 * secs + millis; |
| } |
| |
| /** |
| * Parses a floating-point number describing elapsed time. |
| * The returned number is a number of elapsed milliseconds. |
| * |
| * @param string represeting non-negative floating-point number of seconds |
| * @return integer representing number of milliseconds (rounded), |
| * or <code>-1</code> if the passed string is <code>null</code> |
| * or if it does not match the {@link #FLOAT_NUMBER_REGEX} pattern |
| */ |
| public int parseTimeMillisNoNFE(String timeStr) { |
| if ((timeStr == null) |
| || !getFloatNumPattern().matcher(timeStr).matches()) { |
| return -1; |
| } |
| try { |
| return parseTimeMillis(timeStr); |
| } catch (NumberFormatException ex) { |
| assert false; |
| return -1; |
| } |
| } |
| |
| /** |
| * Trims leading and trailing spaces and tabs from a string. |
| * |
| * @param string string to remove spaces and tabs from |
| * @return the trimmed string, or the passed string if no trimming |
| * was necessary |
| */ |
| public static String specialTrim(String string) { |
| |
| /* Handle the trivial case: */ |
| final int len = string.length(); |
| if (len == 0) { |
| return string; |
| } |
| |
| final char[] chars = string.toCharArray(); |
| char c; |
| |
| int lead = 0; |
| while (lead < len) { |
| c = chars[lead]; |
| if ((c != ' ') && (c != '\t')) { |
| break; |
| } |
| lead++; |
| } |
| |
| /* Handle a corner case: */ |
| if (lead == len) { |
| return string.substring(len); |
| } |
| |
| int trail = len; |
| do { |
| c = chars[--trail]; |
| } while ((c == ' ') || (c == '\t')); |
| |
| if ((lead == 0) && (trail == len - 1)) { |
| return string; |
| } else { |
| return string.substring(lead, trail + 1); |
| } |
| } |
| |
| } |
