diff options
Diffstat (limited to 'regex')
20 files changed, 0 insertions, 9086 deletions
diff --git a/regex/MODULE_LICENSE_APACHE2 b/regex/MODULE_LICENSE_APACHE2 deleted file mode 100644 index e69de29..0000000 --- a/regex/MODULE_LICENSE_APACHE2 +++ /dev/null diff --git a/regex/src/main/java/java/util/regex/MatchResult.java b/regex/src/main/java/java/util/regex/MatchResult.java deleted file mode 100644 index fa67ba6..0000000 --- a/regex/src/main/java/java/util/regex/MatchResult.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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 java.util.regex; - -/** - * Holds the results of a successful match of a {@link Pattern} against a - * given string. The result is divided into groups, with one group for each - * pair of parentheses in the regular expression and an additional group for - * the whole regular expression. The start, end, and contents of each group - * can be queried. - * - * @see Matcher - * @see Matcher#toMatchResult() - * - * @since Android 1.0 - */ -public interface MatchResult { - - /** - * Returns the index of the first character following the text that matched - * the whole regular expression. - * - * @return the character index. - * - * @since Android 1.0 - */ - int end(); - - /** - * Returns the index of the first character following the text that matched - * a given group. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * - * @return the character index. - * - * @since Android 1.0 - */ - int end(int group); - - /** - * Returns the text that matched the whole regular expression. - * - * @return the text. - * - * @since Android 1.0 - */ - String group(); - - /** - * Returns the text that matched a given group of the regular expression. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * - * @return the text that matched the group. - * - * @since Android 1.0 - */ - String group(int group); - - /** - * Returns the number of groups in the result, which is always equal to - * the number of groups in the original regular expression. - * - * @return the number of groups. - * - * @since Android 1.0 - */ - int groupCount(); - - /** - * Returns the index of the first character of the text that matched - * the whole regular expression. - * - * @return the character index. - * - * @since Android 1.0 - */ - int start(); - - /** - * Returns the index of the first character of the text that matched a given - * group. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * - * @return the character index. - * - * @since Android 1.0 - */ - int start(int group); -} diff --git a/regex/src/main/java/java/util/regex/MatchResultImpl.java b/regex/src/main/java/java/util/regex/MatchResultImpl.java deleted file mode 100644 index 795f2f6..0000000 --- a/regex/src/main/java/java/util/regex/MatchResultImpl.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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 java.util.regex; - -/** - * Holds the results of a successful match of a regular expression against a - * given string. Only used internally, thus sparsely documented (though the - * defining public interface has full documentation). - * - * @see java.util.regex.MatchResult - */ -class MatchResultImpl implements MatchResult { - - /** - * Holds the original input text. - */ - private String text; - - /** - * Holds the offsets of the groups in the input text. The first two - * elements specifiy start and end of the zero group, the next two specify - * group 1, and so on. - */ - private int[] offsets; - - MatchResultImpl(String text, int[] offsets) { - this.text = text; - this.offsets = offsets.clone(); - } - - public int end() { - return end(0); - } - - public int end(int group) { - return offsets[2 * group + 1]; - } - - public String group() { - return text.substring(start(), end()); - } - - public String group(int group) { - int from = offsets[group * 2]; - int to = offsets[(group * 2) + 1]; - if (from == -1 || to == -1) { - return null; - } else { - return text.substring(from, to); - } - } - - public int groupCount() { - return (offsets.length / 2) - 1; - } - - public int start() { - return start(0); - } - - public int start(int group) { - return offsets[2 * group]; - } - -} diff --git a/regex/src/main/java/java/util/regex/Matcher.java b/regex/src/main/java/java/util/regex/Matcher.java deleted file mode 100644 index e3e4874..0000000 --- a/regex/src/main/java/java/util/regex/Matcher.java +++ /dev/null @@ -1,779 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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 java.util.regex; - -import com.ibm.icu4jni.regex.NativeRegEx; - -/** - * Provides a means of matching regular expressions against a given input, - * finding occurrences of regular expressions in a given input, or replacing - * parts of a given input. A {@code Matcher} instance has an associated {@link - * Pattern} instance and an input text. A typical use case is to - * iteratively find all occurrences of the {@code Pattern}, until the end of - * the input is reached, as the following example illustrates: - * - * <p/> - * - * <pre> - * Pattern p = Pattern.compile("[A-Za-z]+"); - * - * Matcher m = p.matcher("Hello, Android!"); - * while (m.find()) { - * System.out.println(m.group()); // prints "Hello" and "Android" - * } - * </pre> - * - * <p/> - * - * The {@code Matcher} has a state that results from the previous operations. - * For example, it knows whether the most recent attempt to find the - * {@code Pattern} was successful and at which position the next attempt would - * resume the search. Depending on the application's needs, it may become - * necessary to explicitly {@link #reset()} this state from time to time. - * - * @since Android 1.0 - */ -public final class Matcher implements MatchResult { - - /** - * Holds the pattern, that is, the compiled regular expression. - */ - private Pattern pattern; - - /** - * Holds the handle for the native version of the pattern. - */ - private int nativePattern; - - /** - * Holds the input text. - */ - private String input = ""; - - /** - * Holds the start of the region, or 0 if the matching should start at the - * beginning of the text. - */ - private int regionStart; - - /** - * Holds the end of the region, or input.length() if the matching should - * go until the end of the input. - */ - private int regionEnd; - - /** - * Reflects whether we just reset the matcher or whether we already - * started some find/replace operations. - */ - private boolean searching; - - /** - * Holds the position where the next find operation will take place. - */ - private int findPos; - - /** - * Holds the position where the next append operation will take place. - */ - private int appendPos; - - /** - * Reflects whether a match has been found during the most recent find - * operation. - */ - private boolean matchFound; - - /** - * Holds the offsets for the most recent match. - */ - private int[] matchOffsets; - - /** - * Reflects whether the bounds of the region are anchoring. - */ - private boolean anchoringBounds = true; - - /** - * Reflects whether the bounds of the region are transparent. - */ - private boolean transparentBounds; - - /** - * Creates a matcher for a given combination of pattern and input. Both - * elements can be changed later on. - * - * @param pattern - * the pattern to use. - * @param input - * the input to use. - */ - Matcher(Pattern pattern, CharSequence input) { - usePattern(pattern); - reset(input); - } - - /** - * Resets the Matcher. A new input sequence and a new region can be - * specified. Results of a previous find get lost. The next attempt to find - * an occurrence of the Pattern in the string will start at the beginning of - * the region. This is the internal version of reset() to which the several - * public versions delegate. - * - * @param input - * the input sequence. - * @param start - * the start of the region. - * @param end - * the end of the region. - * - * @return the matcher itself. - */ - private Matcher reset(CharSequence input, int start, int end) { - if (input == null) { - throw new IllegalArgumentException(); - } - - if (start < 0 || end < 0 || start > input.length() || - end > input.length() || start > end) { - throw new IllegalArgumentException(); - } - - // Maybe should have a reset() here, but it makes thing worse... - // NativeRegEx.reset(nativePattern, 0); - - if (!input.equals(this.input)) { - this.input = input.toString(); - - NativeRegEx.setText(nativePattern, this.input); - - regionStart = 0; - regionEnd = input.length(); - } - - if (start != regionStart || end != regionEnd) { - regionStart = start; - regionEnd = end; - - NativeRegEx.setRegion(nativePattern, regionStart, regionEnd); - } - - searching = false; - matchFound = false; - findPos = regionStart; - appendPos = 0; - - return this; - } - - /** - * Resets the {@code Matcher}. This results in the region being set to the - * whole input. Results of a previous find get lost. The next attempt to - * find an occurrence of the {@link Pattern} in the string will start at the - * beginning of the input. - * - * @return the {@code Matcher} itself. - * - * @since Android 1.0 - */ - public Matcher reset() { - return reset(input, 0, input.length()); - } - - /** - * Provides a new input and resets the {@code Matcher}. This results in the - * region being set to the whole input. Results of a previous find get lost. - * The next attempt to find an occurrence of the {@link Pattern} in the - * string will start at the beginning of the input. - * - * @param input - * the new input sequence. - * - * @return the {@code Matcher} itself. - * - * @since Android 1.0 - */ - public Matcher reset(CharSequence input) { - return reset(input, 0, input.length()); - } - - /** - * Sets a new pattern for the {@code Matcher}. Results of a previous find - * get lost. The next attempt to find an occurrence of the {@link Pattern} - * in the string will start at the beginning of the input. - * - * @param pattern - * the new {@code Pattern}. - * - * @return the {@code Matcher} itself. - * - * @since Android 1.0 - */ - public Matcher usePattern(Pattern pattern) { - if (pattern == null) { - throw new IllegalArgumentException(); - } - - this.pattern = pattern; - - if (nativePattern != 0) { - NativeRegEx.close(nativePattern); - } - nativePattern = NativeRegEx.clone(pattern.mNativePattern); - - if (input != null) { - NativeRegEx.setText(nativePattern, input); - NativeRegEx.setRegion(nativePattern, regionStart, regionEnd); - NativeRegEx.useAnchoringBounds(nativePattern, anchoringBounds); - NativeRegEx.useTransparentBounds(nativePattern, transparentBounds); - } - - matchOffsets = new int[(this.pattern.mGroupCount + 1) * 2]; - matchFound = false; - return this; - } - - /** - * Returns the {@link Pattern} instance used inside this matcher. - * - * @return the {@code Pattern} instance. - * - * @since Android 1.0 - */ - public Pattern pattern() { - return pattern; - } - - /** - * Returns the number of groups in the results, which is always equal to - * the number of groups in the original regular expression. - * - * @return the number of groups. - * - * @since Android 1.0 - */ - public int groupCount() { - return pattern.mGroupCount; - } - - /** - * Resets this matcher and sets a region. Only characters inside the region - * are considered for a match. - * - * @param start - * the first character of the region. - * @param end - * the first character after the end of the region. - * @return the {@code Matcher} itself. - * @since Android 1.0 - */ - public Matcher region(int start, int end) { - return reset(input, start, end); - } - - /** - * Returns this matcher's region start, that is, the first character that is - * considered for a match. - * - * @return the start of the region. - * @since Android 1.0 - */ - public int regionStart() { - return regionStart; - } - - /** - * Returns this matcher's region end, that is, the first character that is - * not considered for a match. - * - * @return the end of the region. - * @since Android 1.0 - */ - public int regionEnd() { - return regionEnd; - } - - /** - * Determines whether this matcher has anchoring bounds enabled or not. When - * anchoring bounds are enabled, the start and end of the input match the - * '^' and '$' meta-characters, otherwise not. Anchoring bounds are enabled - * by default. - * - * @param value - * the new value for anchoring bounds. - * @return the {@code Matcher} itself. - * @since Android 1.0 - */ - public Matcher useAnchoringBounds(boolean value) { - anchoringBounds = value; - NativeRegEx.useAnchoringBounds(nativePattern, value); - return this; - } - - /** - * Indicates whether this matcher has anchoring bounds enabled. When - * anchoring bounds are enabled, the start and end of the input match the - * '^' and '$' meta-characters, otherwise not. Anchoring bounds are enabled - * by default. - * - * @return true if (and only if) the {@code Matcher} uses anchoring bounds. - * @since Android 1.0 - */ - public boolean hasAnchoringBounds() { - return anchoringBounds; - } - - /** - * Determines whether this matcher has transparent bounds enabled or not. - * When transparent bounds are enabled, the parts of the input outside the - * region are subject to lookahead and lookbehind, otherwise they are not. - * Transparent bounds are disabled by default. - * - * @param value - * the new value for transparent bounds. - * @return the {@code Matcher} itself. - * @since Android 1.0 - */ - public Matcher useTransparentBounds(boolean value) { - transparentBounds = value; - NativeRegEx.useTransparentBounds(nativePattern, value); - return this; - } - - /** - * Indicates whether this matcher has transparent bounds enabled. When - * transparent bounds are enabled, the parts of the input outside the region - * are subject to lookahead and lookbehind, otherwise they are not. - * Transparent bounds are disabled by default. - * - * @return true if (and only if) the {@code Matcher} uses anchoring bounds. - * @since Android 1.0 - */ - public boolean hasTransparentBounds() { - return transparentBounds; - } - - /** - * Makes sure that a successful match has been made. Is invoked internally - * from various places in the class. - * - * @throws IllegalStateException - * if no successful match has been made. - * - * @since Android 1.0 - */ - private void ensureMatch() throws IllegalStateException { - if (!matchFound) { - throw new IllegalStateException("No successful match so far"); - } - } - - /** - * Returns the next occurrence of the {@link Pattern} in the input. If a - * previous match was successful, the method continues the search from the - * first character following that match in the input. Otherwise it searches - * either from the region start (if one has been set), or from position 0. - * - * @return true if (and only if) a match has been found. - * @since Android 1.0 - */ - public boolean find() { - if (!searching) { - searching = true; - matchFound = NativeRegEx.find(nativePattern, -1); - } else { - matchFound = NativeRegEx.findNext(nativePattern); - } - - if (matchFound) { - NativeRegEx.startEnd(nativePattern, matchOffsets); - findPos = matchOffsets[1]; - } - - return matchFound; - } - - /** - * Returns the next occurrence of the {@link Pattern} in the input. The - * method starts the search from the given character in the input. - * - * @param start - * The index in the input at which the find operation is to - * begin. If this is less than the start of the region, it is - * automatically adjusted to that value. If it is beyond the end - * of the region, the method will fail. - * @return true if (and only if) a match has been found. - * @since Android 1.0 - */ - public boolean find(int start) { - findPos = start; - - if (findPos < regionStart) { - findPos = regionStart; - } else if (findPos >= regionEnd) { - matchFound = false; - return false; - } - - matchFound = NativeRegEx.find(nativePattern, findPos); - if (matchFound) { - NativeRegEx.startEnd(nativePattern, matchOffsets); - findPos = matchOffsets[1]; - } - - return matchFound; - } - - /** - * Tries to match the {@link Pattern} against the entire region (or the - * entire input, if no region has been set). - * - * @return true if (and only if) the {@code Pattern} matches the entire - * region. - * - * @since Android 1.0 - */ - public boolean matches() { - matchFound = NativeRegEx.matches(nativePattern, -1); - if (matchFound) { - NativeRegEx.startEnd(nativePattern, matchOffsets); - findPos = matchOffsets[1]; - } - - return matchFound; - } - - /** - * Tries to match the {@link Pattern}, starting from the beginning of the - * region (or the beginning of the input, if no region has been set). - * Doesn't require the {@code Pattern} to match against the whole region. - * - * @return true if (and only if) the {@code Pattern} matches. - * - * @since Android 1.0 - */ - public boolean lookingAt() { - matchFound = NativeRegEx.lookingAt(nativePattern, -1); - if (matchFound) { - NativeRegEx.startEnd(nativePattern, matchOffsets); - findPos = matchOffsets[1]; - } - - return matchFound; - } - - /** - * Returns the index of the first character of the text that matched the - * whole regular expression. - * - * @return the character index. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public int start() throws IllegalStateException { - return start(0); - } - - /** - * Returns the index of the first character of the text that matched a given - * group. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * @return the character index. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public int start(int group) throws IllegalStateException { - ensureMatch(); - return matchOffsets[group * 2]; - } - - /** - * Returns the index of the first character following the text that matched - * the whole regular expression. - * - * @return the character index. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public int end() { - return end(0); - } - - /** - * Returns the index of the first character following the text that matched - * a given group. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * @return the character index. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public int end(int group) { - ensureMatch(); - return matchOffsets[(group * 2) + 1]; - } - - /** - * Returns the text that matched the whole regular expression. - * - * @return the text. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public String group() { - return group(0); - } - - /** - * Returns the text that matched a given group of the regular expression. - * - * @param group - * the group, ranging from 0 to groupCount() - 1, with 0 - * representing the whole pattern. - * @return the text that matched the group. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public String group(int group) { - ensureMatch(); - int from = matchOffsets[group * 2]; - int to = matchOffsets[(group * 2) + 1]; - if (from == -1 || to == -1) { - return null; - } else { - return input.substring(from, to); - } - } - - /** - * Indicates whether the last match hit the end of the input. - * - * @return true if (and only if) the last match hit the end of the input. - * @since Android 1.0 - */ - public boolean hitEnd() { - return NativeRegEx.hitEnd(nativePattern); - } - - /** - * Indicates whether more input might change a successful match into an - * unsuccessful one. - * - * @return true if (and only if) more input might change a successful match - * into an unsuccessful one. - * @since Android 1.0 - */ - public boolean requireEnd() { - return NativeRegEx.requireEnd(nativePattern); - } - - /** - * Converts the current match into a separate {@link MatchResult} instance - * that is independent from this matcher. The new object is unaffected when - * the state of this matcher changes. - * - * @return the new {@code MatchResult}. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public MatchResult toMatchResult() { - ensureMatch(); - return new MatchResultImpl(input, matchOffsets); - } - - /** - * Appends a literal part of the input plus a replacement for the current - * match to a given {@link StringBuffer}. The literal part is exactly the - * part of the input between the previous match and the current match. The - * method can be used in conjunction with {@link #find()} and - * {@link #appendTail(StringBuffer)} to walk through the input and replace - * all occurrences of the {@code Pattern} with something else. - * - * @param buffer - * the {@code StringBuffer} to append to. - * @param replacement - * the replacement text. - * @return the {@code Matcher} itself. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public Matcher appendReplacement(StringBuffer buffer, String replacement) - throws IllegalStateException { - - buffer.append(input.substring(appendPos, start())); - appendEvaluated(buffer, replacement); - appendPos = end(); - - return this; - } - - /** - * Appends the (unmatched) remainder of the input to the given - * {@link StringBuffer}. The method can be used in conjunction with - * {@link #find()} and {@link #appendReplacement(StringBuffer, String)} to - * walk through the input and replace all matches of the {@code Pattern} - * with something else. - * - * @param buffer - * the {@code StringBuffer} to append to. - * @return the {@code StringBuffer}. - * @throws IllegalStateException - * if no successful match has been made. - * @since Android 1.0 - */ - public StringBuffer appendTail(StringBuffer buffer) { - if (appendPos < regionEnd) { - buffer.append(input.substring(appendPos, regionEnd)); - } - - return buffer; - } - - /** - * Internal helper method to append a given string to a given string buffer. - * If the string contains any references to groups, these are replaced by - * the corresponding group's contents. - * - * @param buffer - * the string buffer. - * @param s - * the string to append. - */ - private void appendEvaluated(StringBuffer buffer, String s) { - boolean escape = false; - boolean dollar = false; - - for (int i = 0; i < s.length(); i++) { - char c = s.charAt(i); - if (c == '\\' && !escape) { - escape = true; - } else if (c == '$' && !escape) { - dollar = true; - } else if (c >= '0' && c <= '9' && dollar) { - buffer.append(group(c - '0')); - dollar = false; - } else { - buffer.append(c); - dollar = false; - escape = false; - } - } - - // This seemingly stupid piece of code reproduces a JDK bug. - if (escape) { - throw new ArrayIndexOutOfBoundsException(s.length()); - } - } - - /** - * Replaces all occurrences of this matcher's pattern in the input with a - * given string. - * - * @param replacement - * the replacement text. - * @return the modified input string. - * @since Android 1.0 - */ - public String replaceAll(String replacement) { - StringBuffer buffer = new StringBuffer(input.length()); - - findPos = 0; - appendPos = 0; - matchFound = false; - searching = false; - - while (find()) { - appendReplacement(buffer, replacement); - } - - return appendTail(buffer).toString(); - } - - /** - * Replaces the first occurrence of this matcher's pattern in the input with - * a given string. - * - * @param replacement - * the replacement text. - * @return the modified input string. - * @since Android 1.0 - */ - public String replaceFirst(String replacement) { - StringBuffer buffer = new StringBuffer(input.length()); - - findPos = 0; - appendPos = 0; - matchFound = false; - searching = false; - - if (find()) { - appendReplacement(buffer, replacement); - } - - return appendTail(buffer).toString(); - } - - /** - * Returns a replacement string for the given one that has all backslashes - * and dollar signs escaped. - * - * @param s - * the input string. - * @return the input string, with all backslashes and dollar signs having - * been escaped. - * @since Android 1.0 - */ - public static String quoteReplacement(String s) { - StringBuffer buffer = new StringBuffer(s.length()); - - for (int i = 0; i < s.length(); i++) { - char c = s.charAt(i); - if (c == '\\' || c == '$') { - buffer.append('\\'); - } - buffer.append(c); - } - - return buffer.toString(); - } - - @Override - protected void finalize() throws Throwable { - try { - if (nativePattern != 0) { - NativeRegEx.close(nativePattern); - } - } - finally { - super.finalize(); - } - } - -} diff --git a/regex/src/main/java/java/util/regex/Pattern.java b/regex/src/main/java/java/util/regex/Pattern.java deleted file mode 100644 index c058db8..0000000 --- a/regex/src/main/java/java/util/regex/Pattern.java +++ /dev/null @@ -1,479 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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 java.util.regex; - -import java.io.Serializable; -import java.util.ArrayList; -import com.ibm.icu4jni.regex.NativeRegEx; - -/** - * Represents a pattern used for matching, searching, or replacing strings. - * {@code Pattern}s are specified in terms of regular expressions and compiled - * using an instance of this class. They are then used in conjunction with a - * {@link Matcher} to perform the actual search. - * <p/> - * A typical use case looks like this: - * <p/> - * <pre> - * Pattern p = Pattern.compile("Hello, A[a-z]*!"); - * - * Matcher m = p.matcher("Hello, Android!"); - * boolean b1 = m.matches(); // true - * - * m.setInput("Hello, Robot!"); - * boolean b2 = m.matches(); // false - * </pre> - * <p/> - * The above code could also be written in a more compact fashion, though this - * variant is less efficient, since {@code Pattern} and {@code Matcher} objects - * are created on the fly instead of being reused. - * fashion: - * <pre> - * boolean b1 = Pattern.matches("Hello, A[a-z]*!", "Hello, Android!"); // true - * boolean b2 = Pattern.matches("Hello, A[a-z]*!", "Hello, Robot!"); // false - * </pre> - * <p/> - * Please consult the <a href="package.html">package documentation</a> for an - * overview of the regular expression syntax used in this class as well as - * Android-specific implementation details. - * - * @see Matcher - * @since Android 1.0 - */ -public final class Pattern implements Serializable { - - private static final long serialVersionUID = 5073258162644648461L; - - /** - * This constant specifies that a pattern matches Unix line endings ('\n') - * only against the '.', '^', and '$' meta characters. - * - * @since Android 1.0 - */ - public static final int UNIX_LINES = 0x01; - - /** - * This constant specifies that a {@code Pattern} is matched - * case-insensitively. That is, the patterns "a+" and "A+" would both match - * the string "aAaAaA". - * <p> - * Note: For Android, the {@code CASE_INSENSITIVE} constant - * (currently) always includes the meaning of the {@link #UNICODE_CASE} - * constant. So if case insensitivity is enabled, this automatically extends - * to all Unicode characters. The {@code UNICODE_CASE} constant itself has - * no special consequences. - * - * @since Android 1.0 - */ - public static final int CASE_INSENSITIVE = 0x02; - - /** - * This constant specifies that a {@code Pattern} may contain whitespace or - * comments. Otherwise comments and whitespace are taken as literal - * characters. - * - * @since Android 1.0 - */ - public static final int COMMENTS = 0x04; - - /** - * This constant specifies that the meta characters '^' and '$' match only - * the beginning and end end of an input line, respectively. Normally, they - * match the beginning and the end of the complete input. - * - * @since Android 1.0 - */ - public static final int MULTILINE = 0x08; - - /** - * This constant specifies that the whole {@code Pattern} is to be taken - * literally, that is, all meta characters lose their meanings. - * - * @since Android 1.0 - */ - public static final int LITERAL = 0x10; - - /** - * This constant specifies that the '.' meta character matches arbitrary - * characters, including line endings, which is normally not the case. - * - * @since Android 1.0 - */ - public static final int DOTALL = 0x20; - - /** - * This constant specifies that a {@code Pattern} is matched - * case-insensitively with regard to all Unicode characters. It is used in - * conjunction with the {@link #CASE_INSENSITIVE} constant to extend its - * meaning to all Unicode characters. - * <p> - * Note: For Android, the {@code CASE_INSENSITIVE} constant - * (currently) always includes the meaning of the {@code UNICODE_CASE} - * constant. So if case insensitivity is enabled, this automatically extends - * to all Unicode characters. The {@code UNICODE_CASE} constant then has no - * special consequences. - * - * @since Android 1.0 - */ - public static final int UNICODE_CASE = 0x40; - - /** - * This constant specifies that a character in a {@code Pattern} and a - * character in the input string only match if they are canonically - * equivalent. It is (currently) not supported in Android. - * - * @since Android 1.0 - */ - public static final int CANON_EQ = 0x80; - - /** - * Holds the regular expression. - */ - private String pattern; - - /** - * Holds the flags used when compiling this pattern. - */ - private int flags; - - /** - * Holds a handle (a pointer, actually) for the native ICU pattern. - */ - transient int mNativePattern; - - /** - * Holds the number of groups in the pattern. - */ - transient int mGroupCount; - - /** - * Compiles a regular expression, creating a new Pattern instance in the - * process. This is actually a convenience method that calls {@link - * #compile(String, int)} with a {@code flags} value of zero. - * - * @param pattern - * the regular expression. - * - * @return the new {@code Pattern} instance. - * - * @throws PatternSyntaxException - * if the regular expression is syntactically incorrect. - * - * @since Android 1.0 - */ - public static Pattern compile(String pattern) throws PatternSyntaxException { - return new Pattern(pattern, 0); - } - - /** - * Compiles a regular expression, creating a new {@code Pattern} instance in - * the process. Allows to set some flags that modify the behavior of the - * {@code Pattern}. - * - * @param pattern - * the regular expression. - * @param flags - * the flags to set. Basically, any combination of the constants - * defined in this class is valid. - * <p> - * Note: Currently, the {@link #CASE_INSENSITIVE} and - * {@link #UNICODE_CASE} constants have slightly special behavior - * in Android, and the {@link #CANON_EQ} constant is not - * supported at all. - * - * @return the new {@code Pattern} instance. - * - * @throws PatternSyntaxException - * if the regular expression is syntactically incorrect. - * - * @see #CANON_EQ - * @see #CASE_INSENSITIVE - * @see #COMMENTS - * @see #DOTALL - * @see #LITERAL - * @see #MULTILINE - * @see #UNICODE_CASE - * @see #UNIX_LINES - * - * @since Android 1.0 - */ - public static Pattern compile(String pattern, int flags) throws PatternSyntaxException { - return new Pattern(pattern, flags); - } - - /** - * Creates a new {@code Pattern} instance from a given regular expression - * and flags. - * - * @param pattern - * the regular expression. - * @param flags - * the flags to set. Any combination of the constants defined in - * this class is valid. - * - * @throws PatternSyntaxException - * if the regular expression is syntactically incorrect. - */ - private Pattern(String pattern, int flags) throws PatternSyntaxException { - if ((flags & CANON_EQ) != 0) { - throw new UnsupportedOperationException("CANON_EQ flag not supported"); - } - - this.pattern = pattern; - this.flags = flags; - - compileImpl(pattern, flags); - } - - /** - * Compiles the given regular expression using the given flags. Used - * internally only. - * - * @param pattern - * the regular expression. - * @param flags - * the flags. - */ - private void compileImpl(String pattern, int flags) throws PatternSyntaxException { - if (pattern == null) { - throw new NullPointerException(); - } - - if ((flags & LITERAL) != 0) { - pattern = quote(pattern); - } - - // These are the flags natively supported by ICU. - // They even have the same value in native code. - flags = flags & (CASE_INSENSITIVE | COMMENTS | MULTILINE | DOTALL | UNIX_LINES); - - mNativePattern = NativeRegEx.open(pattern, flags); - mGroupCount = NativeRegEx.groupCount(mNativePattern); - } - - /** - * Returns the regular expression that was compiled into this - * {@code Pattern}. - * - * @return the regular expression. - * - * @since Android 1.0 - */ - public String pattern() { - return pattern; - } - - /** - * Returns the flags that have been set for this {@code Pattern}. - * - * @return the flags that have been set. A combination of the constants - * defined in this class. - * - * @see #CANON_EQ - * @see #CASE_INSENSITIVE - * @see #COMMENTS - * @see #DOTALL - * @see #LITERAL - * @see #MULTILINE - * @see #UNICODE_CASE - * @see #UNIX_LINES - * - * @since Android 1.0 - */ - public int flags() { - return flags; - } - - /** - * Returns a {@link Matcher} for the {@code Pattern} and a given input. The - * {@code Matcher} can be used to match the {@code Pattern} against the - * whole input, find occurrences of the {@code Pattern} in the input, or - * replace parts of the input. - * - * @param input - * the input to process. - * - * @return the resulting {@code Matcher}. - * - * @since Android 1.0 - */ - public Matcher matcher(CharSequence input) { - return new Matcher(this, input); - } - - /** - * Tries to match a given regular expression against a given input. This is - * actually nothing but a convenience method that compiles the regular - * expression into a {@code Pattern}, builds a {@link Matcher} for it, and - * then does the match. If the same regular expression is used for multiple - * operations, it is recommended to compile it into a {@code Pattern} - * explicitly and request a reusable {@code Matcher}. - * - * @param regex - * the regular expression. - * @param input - * the input to process. - * - * @return true if and only if the {@code Pattern} matches the input. - * - * @see Pattern#compile(java.lang.String, int) - * @see Matcher#matches() - * - * @since Android 1.0 - */ - static public boolean matches(String regex, CharSequence input) { - return new Matcher(new Pattern(regex, 0), input).matches(); - } - - /** - * Splits a given input around occurrences of a regular expression. This is - * a convenience method that is equivalent to calling the method - * {@link #split(java.lang.CharSequence, int)} with a limit of 0. - * - * @param input - * the input sequence. - * - * @return the resulting array. - * - * @since Android 1.0 - */ - public String[] split(CharSequence input) { - return split(input, 0); - } - - /** - * Splits the given input sequence around occurrences of the {@code Pattern}. - * The function first determines all occurrences of the {@code Pattern} - * inside the input sequence. It then builds an array of the - * "remaining" strings before, in-between, and after these - * occurrences. An additional parameter determines the maximal number of - * entries in the resulting array and the handling of trailing empty - * strings. - * - * @param inputSeq - * the input sequence. - * @param limit - * Determines the maximal number of entries in the resulting - * array. - * <ul> - * <li>For n > 0, it is guaranteed that the resulting array - * contains at most n entries. - * <li>For n < 0, the length of the resulting array is - * exactly the number of occurrences of the {@code Pattern} +1. - * All entries are included. - * <li>For n == 0, the length of the resulting array is at most - * the number of occurrences of the {@code Pattern} +1. Empty - * strings at the end of the array are not included. - * </ul> - * - * @return the resulting array. - * - * @since Android 1.0 - */ - public String[] split(CharSequence inputSeq, int limit) { - int maxLength = limit <= 0 ? Integer.MAX_VALUE : limit; - - String input = inputSeq.toString(); - ArrayList<String> list = new ArrayList<String>(); - - Matcher matcher = new Matcher(this, inputSeq); - int savedPos = 0; - - // Add text preceding each occurrence, if enough space. Only do this for - // non-empty input sequences, because otherwise we'd add the "trailing - // empty string" twice. - if (inputSeq.length() != 0) { - while(matcher.find() && list.size() + 1 < maxLength) { - list.add(input.substring(savedPos, matcher.start())); - savedPos = matcher.end(); - } - } - - // Add trailing text if enough space. - if (list.size() < maxLength) { - if (savedPos < input.length()) { - list.add(input.substring(savedPos)); - } else { - list.add(""); - } - } - - // Remove trailing spaces, if limit == 0 is requested. - if (limit == 0) { - int i = list.size() - 1; - // Don't remove 1st element, since array must not be empty. - while(i > 0 && "".equals(list.get(i))) { - list.remove(i); - i--; - } - } - - return list.toArray(new String[list.size()]); - } - - /** - * Quotes a given string using "\Q" and "\E", so that all other - * meta-characters lose their special meaning. If the string is used for a - * {@code Pattern} afterwards, it can only be matched literally. - * - * @param s - * the string to quote. - * - * @return the quoted string. - * - * @since Android 1.0 - */ - public static String quote(String s) { - StringBuffer sb = new StringBuffer().append("\\Q"); - int apos = 0; - int k; - while ((k = s.indexOf("\\E", apos)) >= 0) { - sb.append(s.substring(apos, k + 2)).append("\\\\E\\Q"); - apos = k + 2; - } - - return sb.append(s.substring(apos)).append("\\E").toString(); - } - - @Override - public String toString() { - return pattern; - } - - @Override - protected void finalize() throws Throwable { - try { - if (mNativePattern != 0) { - NativeRegEx.close(mNativePattern); - } - } - finally { - super.finalize(); - } - } - - /** - * Provides serialization support - */ - private void readObject(java.io.ObjectInputStream s) - throws java.io.IOException, ClassNotFoundException { - s.defaultReadObject(); - - compileImpl(pattern, flags); - } - -} diff --git a/regex/src/main/java/java/util/regex/PatternSyntaxException.java b/regex/src/main/java/java/util/regex/PatternSyntaxException.java deleted file mode 100644 index e4d5abd..0000000 --- a/regex/src/main/java/java/util/regex/PatternSyntaxException.java +++ /dev/null @@ -1,146 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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 java.util.regex; - -import java.util.Arrays; - -/** - * Encapsulates a syntax error that occurred during the compilation of a - * {@link Pattern}. Might include a detailed description, the original regular - * expression, and the index at which the error occurred. - * - * @see Pattern#compile(String) - * @see Pattern#compile(java.lang.String,int) - * - * @since Android 1.0 - */ -public class PatternSyntaxException extends IllegalArgumentException { - - private static final long serialVersionUID = -3864639126226059218L; - - /** - * Holds the syntactically incorrect regular expression, or null if the - * regular expression is not known. - */ - private String pattern; - - /** - * Holds the description of the syntax error, or null if the description is - * not known. - */ - private String description; - - /** - * Holds the index around which the error occured, or -1, in case it is - * unknown. - */ - private int index = -1; - - /** - * Creates a new PatternSyntaxException for a given message, pattern, and - * error index. - * - * @param description - * the description of the syntax error, or {@code null} if the - * description is not known. - * @param pattern - * the syntactically incorrect regular expression, or - * {@code null} if the regular expression is not known. - * @param index - * the character index around which the error occurred, or -1 if - * the index is not known. - * @since Android 1.0 - */ - public PatternSyntaxException(String description, String pattern, int index) { - this.pattern = pattern; - this.description = description; - this.index = index; - } - - /** - * Returns the syntactically incorrect regular expression. - * - * @return the regular expression. - * - * @since Android 1.0 - */ - public String getPattern() { - return pattern; - } - - /** - * Returns a detailed error message for the exception. The message is - * potentially multi-line, and it might include a detailed description, the - * original regular expression, and the index at which the error occured. - * - * @return the error message. - * - * @since Android 1.0 - */ - @Override - public String getMessage() { - StringBuilder builder = new StringBuilder("Syntax error"); - - if (description != null) { - builder.append(' '); - builder.append(description); - } - - if (index >= 0) { - builder.append(" near index " + index + ":"); - } - - if (pattern != null) { - builder.append('\n'); - builder.append(pattern); - - if (index >= 0) { - char[] spaces = new char[index]; - Arrays.fill(spaces, ' '); - builder.append('\n'); - builder.append(spaces); - builder.append('^'); - } - } - - return builder.toString(); - } - - /** - * Returns the description of the syntax error, or {@code null} if the - * description is not known. - * - * @return the description. - * @since Android 1.0 - */ - public String getDescription() { - return description; - } - - /** - * Returns the character index around which the error occurred, or -1 if the - * index is not known. - * - * @return the index. - * - * @since Android 1.0 - */ - public int getIndex() { - return index; - } - -} diff --git a/regex/src/main/java/java/util/regex/package.html b/regex/src/main/java/java/util/regex/package.html deleted file mode 100644 index 0508f3e..0000000 --- a/regex/src/main/java/java/util/regex/package.html +++ /dev/null @@ -1,884 +0,0 @@ -<html> - <head> - <!-- - /* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed 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. - */ - --> - </head> - <body> - Provides an implementation of regular expressions, which is useful for - matching, searching, and replacing strings based on patterns. The two - fundamental classes are {@link java.util.regex.Pattern} and - {@link java.util.regex.Matcher}. The former - takes a pattern described by means of a regular expression and compiles it - into a special internal representation. The latter matches the compiled - pattern against a given input. - - <h2>Regular expressions</h2> - - A regular expression consists of literal text, meta characters, character - sets, and operators. The latter three have a special meaning when - encountered during the processing of a pattern. - - <ul> - <li> - <a href="#metachars">Meta characters</a> are a special means to describe - single characters in the input text. A common example for a meta - character is the dot '.', which, when used in a regular expression, - matches any character. - </li> - <li> - <a href="#charsets">Character sets</a> are a convenient means to - describe different characters that match a single character in the - input. Character sets are enclosed in angular brackets '[' and ']' - and use the dash '-' for forming ranges. A typical example is - "[0-9a-fA-F]", which describes the set of all hexadecimal digits. - </li> - <li> - <a href="#operators">Operators</a> modify or combine whole regular - expressions, with the result being a regular expression again. An - example for an operator is the asterisk '*', which, together with the - regular expression preceding it, matches zero or more repetitions of - that regular expression. The plus sign '+' is similar, but requires at - least one occurrence. - </li> - </ul> - - Meta characters, the '[' and ']' that form a character set, and operators - normally lose their special meaning when preceded by a backslash '\'. To get - a backslash by itself, use a double backslash. Note that when using regular - expressions in Java source code, some care has to be taken to get the - backslashes right (due to yet another level of escaping being necessary for - Java). - - <p> - - The following table gives some basic examples of regular expressions and - input strings that match them: - - <p> - - <table> - <tr> - <th> - Regular expression - </th> - <th> - Matched string(s) - </th> - </tr> - <tr> - <td> - "Hello, World!" - </td> - <td> - "Hello, World!" - </td> - </tr> - <tr> - <td> - "Hello, World." - </td> - <td> - "Hello, World!", "Hello, World?" - </td> - </tr> - <tr> - <td> - "Hello, .*d!" - </td> - <td> - "Hello, World!", "Hello, Android!", "Hello, Dad!" - </td> - </tr> - <tr> - <td> - "[0-9]+ green bottles" - </td> - <td> - "0 green bottles", "25 green bottles", "1234 green bottles" - </td> - </tr> - </table> - - <p> - - The following section describe the various features in detail. The are also - some <a href="#impnotes">implementation notes</a> at the end. - - <p> - - <a name="metachars"></a> - <h2>Meta characters</h2> - - The following two tables lists the meta characters understood in regular - expressions. - - <p> - - <!-- ICU-copied documentation begins here --> - - <table> - <tr> - <th> - Meta character - </th> - <th> - Description - </th> - </tr> - <tr> - <td> - \a - </td> - <td> - Match a BELL, \u0007. - </td> - </tr> - <tr> - <td> - \A - </td> - <td> - Match at the beginning of the input. Differs from ^ in that - \A will not match after a new line within the input. - </td> - </tr> - <tr> - <td> - \b, outside of a <a href="#charsets">character set</a> - </td> - <td> - Match if the current position is a word boundary. Boundaries - occur at the transitions between word (\w) and non-word (\W) - characters, with combining marks ignored. - </td> - </tr> - <tr> - <td> - \b, within a <a href="#charsets">character set</a> - </td> - <td> - Match a BACKSPACE, \u0008. - </td> - </tr> - <tr> - <td> - \B - </td> - <td> - Match if the current position is not a word boundary. - </td> - </tr> - <tr> - <td> - \cX - </td> - <td> - Match a control-X character (replace X with actual character). - </td> - </tr> - <tr> - <td> - \e - </td> - <td> - Match an ESCAPE, \u001B. - </td> - </tr> - <tr> - <td> - \E - </td> - <td> - Ends quoting started by \Q. Meta characters, character classes, and - operators become active again. - </td> - </tr> - <tr> - <td> - \f - </td> - <td> - Match a FORM FEED, \u000C. - </td> - </tr> - <tr> - <td> - \G - </td> - <td> - Match if the current position is at the end of the previous - match. - </td> - </tr> - <tr> - <td> - \n - </td> - <td> - Match a LINE FEED, \u000A. - </td> - </tr> - <tr> - <td> - \N{UNICODE CHARACTER NAME} - </td> - <td> - Match the named Unicode character. - </td> - </tr> - <tr> - <td> - \Q - </td> - <td> - Quotes all following characters until \E. The following text is - treated as literal. - </td> - </tr> - <tr> - <td> - \r - </td> - <td> - Match a CARRIAGE RETURN, \u000D. - </td> - </tr> - <tr> - <td> - \t - </td> - <td> - Match a HORIZONTAL TABULATION, \u0009. - </td> - </tr> - <tr> - <td> - \uhhhh - </td> - <td> - Match the character with the hex value hhhh. - </td> - </tr> - <tr> - <td> - \Uhhhhhhhh - </td> - <td> - Match the character with the hex value hhhhhhhh. Exactly - eight hex digits must be provided, even though the largest Unicode - code point is \U0010ffff. - </td> - </tr> - <tr> - <td> - \x{hhhh} - </td> - <td> - Match the character with the hex value hhhh. From one to six hex - digits may be supplied. - </td> - </tr> - <tr> - <td> - \xhh - </td> - <td> - Match the character with the hex value hh. - </td> - </tr> - <tr> - <td> - \Z - </td> - <td> - Match if the current position is at the end of input, but - before the final line terminator, if one exists. - </td> - </tr> - <tr> - <td> - \z - </td> - <td> - Match if the current position is at the end of input. - </td> - </tr> - <tr> - <td> - \0n, \0nn, \0nnn - </td> - <td> - Match the character with the octal value n, nn, or nnn. Maximum - value is 0377. - </td> - </tr> - <tr> - <td> - \n - </td> - <td> - Back Reference. Match whatever the nth capturing group - matched. n must be a number > 1 and < total number of capture - groups in the pattern. Note: Octal escapes, such as \012, are not - supported in ICU regular expressions - </td> - </tr> - <tr> - <td> - [character set] - </td> - <td> - Match any one character from the character set. See - <a href="#charsets">character sets</a> for a full description of what - may appear between the angular brackets. - </td> - </tr> - <tr> - <td> - . - </td> - <td> - Match any character. - </td> - </tr> - <tr> - <td> - ^ - </td> - <td> - Match at the beginning of a line. - </td> - </tr> - <tr> - <td> - $ - </td> - <td> - Match at the end of a line. - </td> - </tr> - <tr> - <td> - \ - </td> - <td> - Quotes the following character, so that is loses any special - meaning it might have. - </td> - </tr> - </table> - - <!-- ICU-copied documentation begins here --> - - <p> - - <a name="charsets"></a> - <h2>Character sets</h2> - - The following table lists the syntax elements allowed inside a character - set: - - <p> - - <table> - <tr> - <th> - Element - </th> - <th> - Description - </th> - </tr> - <tr> - <td> - [a] - </td> - <td> - The character set consisting of the letter 'a' only. - </td> - </tr> - <tr> - <td> - [xyz] - </td> - <td> - The character set consisting of the letters 'x', 'y', and 'z', - described by explicit enumeration. - </td> - </tr> - <tr> - <td> - [x-z] - </td> - <td> - The character set consisting of the letters 'x', 'y', and 'z', - described by means of a range. - </td> - </tr> - <tr> - <td> - [^xyz] - </td> - <td> - The character set consisting of everything but the letters 'x', 'y', - and 'z'. - </td> - </tr> - <tr> - <td> - [[a-f][0-9]] - </td> - <td> - The character set formed by building the union of the two character - sets [a-f] and [0-9]. - </td> - </tr> - <tr> - <td> - [[a-z]&&[jkl]] - </td> - <td> - The character set formed by building the intersection of the two - character sets [a-z] and [jkl]. You can also use a single '&', but - this regular expression might not be <a href="#impnotes">portable</a>. - </td> - </tr> - <tr> - <td> - [[a-z]--[jkl]] - </td> - <td> - The character set formed by building the difference of the two - character sets [a-z] and [jkl]. You can also use a single '-'. This - operator is generally not <a href="#impnotes">portable</a>. - </td> - </tr> - </table> - - <p> - - A couple of frequently used character sets are predefined and named. - These can be referenced by their name, but behave otherwise similar to - explicit character sets. The following table lists them: - - <p> - - <table> - <tr> - <th> - Character set - </th> - <th> - Description - </th> - </tr> - <tr> - <td> - \d, \D - </td> - <td> - The set consisting of all digit characters (\d) or the opposite of - it (\D). - </td> - </tr> - <tr> - <td> - \s, \S - </td> - <td> - The set consisting of all space characters (\s) or the opposite of - it (\S). - </td> - </tr> - <tr> - <td> - \w, \W - </td> - <td> - The set consisting of all word characters (\w) or the opposite - of it (\W). - </td> - </tr> - <tr> - <td> - \X - </td> - <td> - The set of all grapheme clusters. - </td> - </tr> - <tr> - <td> - \p{NAME}, \P{NAME} - </td> - <td> - The Posix set with the specified NAME (\p{}) or the opposite - of it (\P{}) - Legal values for NAME are 'Alnum', 'Alpha', 'ASCII', - 'Blank', 'Cntrl', 'Digit', 'Graph', 'Lower', 'Print', 'Punct', - 'Upper', 'XDigit' . - </td> - </tr> - <tr> - <td> - \p{inBLOCK}, \P{inBLOCK} - </td> - <td> - The character set equivalent to the given Unicode BLOCK (\p{}) or - the opposite of it (\P{}). An example for a legal BLOCK name is - 'Hebrew', meaning, unsurprisingly, all Hebrew characters. - </td> - </tr> - <tr> - <td> - \p{CATEGORY}, \P{CATEGORY} - </td> - <td> - The character set equivalent to the Unicode CATEGORY (\p{}) or the - opposite of it (\P{}). An example for a legal CATEGORY name is 'Lu', - meaning all uppercase letters. - </td> - </tr> - <tr> - <td> - \p{javaMETHOD}, \P{javaMETHOD} - </td> - <td> - The character set equivalent to the isMETHOD() operation of the - {@link java.lang.Character} class (\p{}) or the opposite of it (\P{}). - </td> - </tr> - </table> - - <p> - - <a name="operators"></a> - <h2>Operators</h2> - - The following table lists the operators understood inside regular - expressions: - - <p> - - <!-- ICU-copied documentation begins here --> - - <table> - <tr> - <th> - Operator - </th> - <th> - Description - </th> - </tr> - <tr> - <td> - | - </td> - <td> - Alternation. A|B matches either A or B. - </td> - </tr> - <tr> - <td> - * - </td> - <td> - Match 0 or more times. Match as many times as possible. - </td> - </tr> - <tr> - <td> - + - </td> - <td> - Match 1 or more times. Match as many times as possible. - </td> - </tr> - <tr> - <td> - ? - </td> - <td> - Match zero or one times. Prefer one. - </td> - </tr> - <tr> - <td> - {n} - </td> - <td> - Match exactly n times - </td> - </tr> - <tr> - <td> - {n,} - </td> - <td> - Match at least n times. Match as many times as possible. - </td> - </tr> - <tr> - <td> - {n,m} - </td> - <td> - Match between n and m times. Match as many times as possible, - but not more than m. - </td> - </tr> - <tr> - <td> - *? - </td> - <td> - Match 0 or more times. Match as few times as possible. - </td> - </tr> - <tr> - <td> - +? - </td> - <td> - Match 1 or more times. Match as few times as possible. - </td> - </tr> - <tr> - <td> - ?? - </td> - <td> - Match zero or one times. Prefer zero. - </td> - </tr> - <tr> - <td> - {n}? - </td> - <td> - Match exactly n times. - </td> - </tr> - <tr> - <td> - {n,}? - </td> - <td> - Match at least n times, but no more than required for an - overall pattern match - </td> - </tr> - <tr> - <td> - {n,m}? - </td> - <td> - Match between n and m times. Match as few times as possible, - but not less than n. - </td> - </tr> - <tr> - <td> - *+ - </td> - <td> - Match 0 or more times. Match as many times as possible when - first encountered, do not retry with fewer even if overall match - fails (Possessive Match) - </td> - </tr> - <tr> - <td> - ++ - </td> - <td> - Match 1 or more times. Possessive match. - </td> - </tr> - <tr> - <td> - ?+ - </td> - <td> - Match zero or one times. Possessive match. - </td> - </tr> - <tr> - <td> - {n}+ - </td> - <td> - Match exactly n times. - </td> - </tr> - <tr> - <td> - {n,}+ - </td> - <td> - Match at least n times. Possessive Match. - </td> - </tr> - <tr> - <td> - {n,m}+ - </td> - <td> - Match between n and m times. Possessive Match. - </td> - </tr> - <tr> - <td> - ( ... ) - </td> - <td> - Capturing parentheses. Range of input that matched the - parenthesized subexpression is available after the match. - </td> - </tr> - <tr> - <td> - (?: ... ) - </td> - <td> - Non-capturing parentheses. Groups the included pattern, but - does not provide capturing of matching text. Somewhat more efficient - than capturing parentheses. - </td> - </tr> - <tr> - <td> - (?> ... ) - </td> - <td> - Atomic-match parentheses. First match of the parenthesized - subexpression is the only one tried; if it does not lead to an - overall pattern match, back up the search for a match to a position - before the "(?>" - </td> - </tr> - <tr> - <td> - (?# ... ) - </td> - <td> - Free-format comment (?# comment ). - </td> - </tr> - <tr> - <td> - (?= ... ) - </td> - <td> - Look-ahead assertion. True if the parenthesized pattern - matches at the current input position, but does not advance the - input position. - </td> - </tr> - <tr> - <td> - (?! ... ) - </td> - <td> - Negative look-ahead assertion. True if the parenthesized - pattern does not match at the current input position. Does not - advance the input position. - </td> - </tr> - <tr> - <td> - (?<= ... ) - </td> - <td> - Look-behind assertion. True if the parenthesized pattern - matches text preceding the current input position, with the last - character of the match being the input character just before the - current position. Does not alter the input position. The length of - possible strings matched by the look-behind pattern must not be - unbounded (no * or + operators.) - </td> - </tr> - <tr> - <td> - (?<! ... ) - </td> - <td> - Negative Look-behind assertion. True if the parenthesized - pattern does not match text preceding the current input position, - with the last character of the match being the input character just - before the current position. Does not alter the input position. The - length of possible strings matched by the look-behind pattern must - not be unbounded (no * or + operators.) - </td> - </tr> - <tr> - <td> - (?ismwx-ismwx: ... ) - </td> - <td> - Flag settings. Evaluate the parenthesized expression with the - specified flags enabled or -disabled. - </td> - </tr> - <tr> - <td> - (?ismwx-ismwx) - </td> - <td> - Flag settings. Change the flag settings. Changes apply to the - portion of the pattern following the setting. For example, (?i) - changes to a case insensitive match. - </td> - </tr> - </table> - - <!-- ICU-copied documentation ends here --> - - <p> - - <a name="impnotes"></a> - <h2>Implementation notes</h2> - - The regular expression implementation used in Android is provided by - <a href="http://www.icu-project.org">ICU</a>. The notation for the regular - expressions is mostly a superset of those used in other Java language - implementations. This means that existing applications will normally work as - expected, but in rare cases some regular expression content that is meant to - be literal might be interpreted with a special meaning. The most notable - examples are the single '&', which can also be used as the intersection - operator for <a href="#charsets">character sets</a>, and the intersection - operators '-' and '--'. Also, some of the flags are handled in a - slightly different way: - - <ul> - <li> - The {@link java.util.regex.Pattern#CASE_INSENSITIVE} flag silently - assumes Unicode case-insensitivity. That is, the - {@link java.util.regex.Pattern#UNICODE_CASE} flag is effectively a - no-op. - </li> - <li> - The {@link java.util.regex.Pattern#CANON_EQ} flag is not supported at - all (throws an exception). - </li> - </ul> - - @since Android 1.0 - - </body> -</html> diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/AllTests.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/AllTests.java deleted file mode 100644 index b69c401..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/AllTests.java +++ /dev/null @@ -1,49 +0,0 @@ -/* - * 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.apache.harmony.regex.tests.java.util.regex; - -import junit.framework.Test; -import junit.framework.TestSuite; - -/** - * Provides a test suite for java.util.regex package. - */ -public class AllTests { - - public static void main(String[] args) { - junit.textui.TestRunner.run(suite()); - } - - public static Test suite() { - TestSuite suite = tests.TestSuiteFactory.createTestSuite("Tests for java.util.regex"); - //$JUnit-BEGIN$ - - suite.addTestSuite(Matcher2Test.class); - suite.addTestSuite(MatcherTest.class); - suite.addTestSuite(ModeTest.class); - suite.addTestSuite(Pattern2Test.class); - suite.addTestSuite(PatternErrorTest.class); - suite.addTestSuite(PatternSyntaxExceptionTest.class); - suite.addTestSuite(PatternTest.class); - suite.addTestSuite(ReplaceTest.class); - suite.addTestSuite(SplitTest.class); - - //$JUnit-END$ - return suite; - } -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Matcher2Test.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Matcher2Test.java deleted file mode 100644 index ab0de63..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Matcher2Test.java +++ /dev/null @@ -1,327 +0,0 @@ -/* 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import junit.framework.TestCase; -import java.util.regex.*; - -/** - * Tests Matcher methods - * - */ -@TestTargetClass(java.util.regex.Matcher.class) -public class Matcher2Test extends TestCase { - - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Verifies the basic functionality of toString() method.", - method = "toString", - args = {} - ) - public void test_toString() { - Pattern p = Pattern.compile("foo"); - Matcher m = p.matcher("bar"); - assertNotNull(m.toString()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "start", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "end", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "group", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "start", - args = {int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "end", - args = {int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "group", - args = {int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies start, end, group, usePattern methods with wrong conditions, IllegalStateException should be thrown", - method = "usePattern", - args = {java.util.regex.Pattern.class} - ) - }) - public void testErrorConditions() throws PatternSyntaxException { - // Test match cursors in absence of a match - Pattern p = Pattern.compile("foo"); - Matcher m = p.matcher("bar"); - assertFalse(m.matches()); - - try { - m.start(); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.end(); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.group(); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.start(1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.end(1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.group(1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - // regression test for HARMONY-2418 - try { - m.usePattern(null); - fail("IllegalArgumentException expected"); - } catch (IllegalArgumentException e) { - // PASSED - } - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies end, start, group methods with wrong conditions, IndexOutOfBoundsException, IllegalStateException should be thrown", - method = "start", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies end, start, group methods with wrong conditions, IndexOutOfBoundsException, IllegalStateException should be thrown", - method = "end", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies end, start, group methods with wrong conditions, IndexOutOfBoundsException, IllegalStateException should be thrown", - method = "start", - args = {int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies end, start, group methods with wrong conditions, IndexOutOfBoundsException, IllegalStateException should be thrown", - method = "end", - args = {int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies end, start, group methods with wrong conditions, IndexOutOfBoundsException, IllegalStateException should be thrown", - method = "group", - args = {int.class} - ) - }) - public void testErrorConditions2() throws PatternSyntaxException { - // Test match cursors in absence of a match - Pattern p = Pattern.compile("(foo[0-9])(bar[a-z])"); - Matcher m = p.matcher("foo1barzfoo2baryfoozbar5"); - - assertTrue(m.find()); - assertEquals(0, m.start()); - assertEquals(8, m.end()); - assertEquals(0, m.start(1)); - assertEquals(4, m.end(1)); - assertEquals(4, m.start(2)); - assertEquals(8, m.end(2)); - - try { - m.start(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.end(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.group(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.start(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.end(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.group(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - assertTrue(m.find()); - assertEquals(8, m.start()); - assertEquals(16, m.end()); - assertEquals(8, m.start(1)); - assertEquals(12, m.end(1)); - assertEquals(12, m.start(2)); - assertEquals(16, m.end(2)); - - try { - m.start(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.end(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.group(3); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.start(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.end(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - try { - m.group(-1); - fail("IndexOutOfBoundsException expected"); - } catch (IndexOutOfBoundsException e) { - } - - assertFalse(m.find()); - - try { - m.start(3); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.end(3); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.group(3); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.start(-1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.end(-1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - - try { - m.group(-1); - fail("IllegalStateException expected"); - } catch (IllegalStateException e) { - } - } - - /* - * Regression test for HARMONY-997 - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies that IndexOutOfBoundsException exception is thrown while calling of replaceAll method with incorrect string.", - method = "replaceAll", - args = {java.lang.String.class} - ) - public void testReplacementBackSlash() { - String str = "replace me"; - String replacedString = "me"; - String substitutionString = "\\"; - Pattern pat = Pattern.compile(replacedString); - Matcher mat = pat.matcher(str); - try { - String res = mat.replaceAll(substitutionString); - fail("IndexOutOfBoundsException should be thrown - " + res); - } catch (Exception e) { - } - } -} - diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/MatcherTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/MatcherTest.java deleted file mode 100644 index 5e9137b..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/MatcherTest.java +++ /dev/null @@ -1,1471 +0,0 @@ -/* - * 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.apache.harmony.regex.tests.java.util.regex; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import junit.framework.TestCase; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargets; - -@TestTargetClass( - value = Matcher.class, - untestedMethods= { - @TestTargetNew( - level = TestLevel.NOT_FEASIBLE, - notes = "finalize is hard to test since the implementation only calls a native function", - method = "finalize", - args = {} - ) - } - -) -public class MatcherTest extends TestCase { - String[] testPatterns = { - "(a|b)*abb", - "(1*2*3*4*)*567", - "(a|b|c|d)*aab", - "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*", - "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*", - "(a|b)*(a|b)*A(a|b)*lice.*", - "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" - + "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do" }; - - String[] groupPatterns = { "(a|b)*aabb", "((a)|b)*aabb", "((a|b)*)a(abb)", - "(((a)|(b))*)aabb", "(((a)|(b))*)aa(b)b", "(((a)|(b))*)a(a(b)b)" }; - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "appendReplacement", - args = {java.lang.StringBuffer.class, java.lang.String.class} - ) - public void testAppendReplacement() { - Pattern pat = Pattern.compile("XX"); - Matcher m = pat.matcher("Today is XX-XX-XX ..."); - StringBuffer sb = new StringBuffer(); - - for (int i = 0; m.find(); i++) { - m.appendReplacement(sb, new Integer(i * 10 + i).toString()); - } - m.appendTail(sb); - assertEquals("Today is 0-11-22 ...", sb.toString()); - - pat = Pattern.compile("cat"); - m = pat.matcher("one-cat-two-cats-in-the-yard"); - sb = new StringBuffer(); - Throwable t = null; - m.find(); - try { - m.appendReplacement(null, "dog"); - } catch (NullPointerException e) { - t = e; - } - assertNotNull(t); - t = null; - m.find(); - try { - m.appendReplacement(sb, null); - } catch (NullPointerException e) { - t = e; - } - assertNotNull(t); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "appendReplacement", - args = {java.lang.StringBuffer.class, java.lang.String.class} - ) - public void testAppendReplacementRef() { - Pattern p = Pattern.compile("xx (rur|\\$)"); - Matcher m = p.matcher("xx $ equals to xx rur."); - StringBuffer sb = new StringBuffer(); - for (int i = 1; m.find(); i *= 30) { - String rep = new Integer(i).toString() + " $1"; - m.appendReplacement(sb, rep); - } - m.appendTail(sb); - assertEquals("1 $ equals to 30 rur.", sb.toString()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "replaceAll", - args = {java.lang.String.class} - ) - public void testReplaceAll() { - String input = "aabfooaabfooabfoob"; - String pattern = "a*b"; - Pattern pat = Pattern.compile(pattern); - Matcher mat = pat.matcher(input); - - assertEquals("-foo-foo-foo-", mat.replaceAll("-")); - } - - /** - * @test java.util.regex.Matcher#reset(String) - * test reset(String) method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the reset(CharSequence input) method.", - method = "reset", - args = {java.lang.CharSequence.class} - ) - public void test_resetLjava_lang_String() { - String testPattern = "(abb)"; - String testString1 = "babbabbcccabbabbabbabbabb"; - String testString2 = "cddcddcddcddcddbbbb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString1); - - while (mat.find()); - assertEquals("Reset should return itself 1", mat, mat.reset(testString2)); - assertFalse("After reset matcher should not find pattern in given input", mat.find()); - assertEquals("Reset should return itself 2", mat, mat.reset(testString1)); - assertTrue("After reset matcher should find pattern in given input", mat.find()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "appendReplacement", - args = {java.lang.StringBuffer.class, java.lang.String.class} - ) - public void testAppendSlashes() { - Pattern p = Pattern.compile("\\\\"); - Matcher m = p.matcher("one\\cat\\two\\cats\\in\\the\\yard"); - StringBuffer sb = new StringBuffer(); - while (m.find()) { - m.appendReplacement(sb, "\\\\"); - } - m.appendTail(sb); - assertEquals("one\\cat\\two\\cats\\in\\the\\yard", sb.toString()); - - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "appendTail", - args = {java.lang.StringBuffer.class} - ) - public void testAppendTail() { - Pattern p = Pattern.compile("cat"); - Matcher m = p.matcher("one-cat-two-cats-in-the-yard"); - StringBuffer sb = new StringBuffer(); - while (m.find()) { - m.appendReplacement(sb, "dog"); - } - m.appendTail(sb); - assertEquals("one-dog-two-dogs-in-the-yard", sb.toString()); - - p = Pattern.compile("cat|yard"); - m = p.matcher("one-cat-two-cats-in-the-yard"); - sb = new StringBuffer(); - while (m.find()) { - m.appendReplacement(sb, "dog"); - } - assertEquals("one-dog-two-dogs-in-the-dog", sb.toString()); - m.appendTail(sb); - assertEquals("one-dog-two-dogs-in-the-dog", sb.toString()); - - p = Pattern.compile("cat"); - m = p.matcher("one-cat-two-cats-in-the-yard"); - sb = new StringBuffer(); - while (m.find()) { - m.appendReplacement(sb, "dog"); - } - Throwable t = null; - try { - m.appendTail(null); - } catch (NullPointerException e) { - t = e; - } - assertNotNull(t); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies replaceFirst(String replacement) method. ", - method = "replaceFirst", - args = {java.lang.String.class} - ) - public void testReplaceFirst() { - String input = "zzzdogzzzdogzzz"; - String pattern = "dog"; - Pattern pat = Pattern.compile(pattern); - Matcher mat = pat.matcher(input); - - assertEquals("zzzcatzzzdogzzz", mat.replaceFirst("cat")); - } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies pattern() method.", - method = "pattern", - args = {} - ) - public void testPattern() { - for (String element : testPatterns) { - Pattern test = Pattern.compile(element); - assertEquals(test, test.matcher("aaa").pattern()); - } - - for (String element : testPatterns) { - assertEquals(element, Pattern.compile(element).matcher("aaa") - .pattern().toString()); - } - } - - /** - * @test java.util.regex.Matcher#reset() - * test reset() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the reset() method. ", - method = "reset", - args = {} - ) - public void test_reset() { - String testPattern = "(abb)"; - String testString = "babbabbcccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - while (mat.find()); - assertEquals("Reset should return itself", mat, mat.reset()); - assertTrue("After reset matcher should find pattern in given input", mat.find()); - } - - /* - * Class under test for String group(int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies group(int group) method.", - method = "group", - args = {int.class} - ) - public void testGroupint() { - String positiveTestString = "ababababbaaabb"; - String negativeTestString = "gjhfgdsjfhgcbv"; - - // test IndexOutOfBoundsException - // // - for (int i = 0; i < groupPatterns.length; i++) { - Pattern test = Pattern.compile(groupPatterns[i]); - Matcher mat = test.matcher(positiveTestString); - mat.matches(); - try { - // groupPattern <index + 1> equals to number of groups - // of the specified pattern - // // - mat.group(i + 2); - fail("IndexOutBoundsException expected"); - mat.group(i + 100); - fail("IndexOutBoundsException expected"); - mat.group(-1); - fail("IndexOutBoundsException expected"); - mat.group(-100); - fail("IndexOutBoundsException expected"); - } catch (IndexOutOfBoundsException iobe) { - } - } - - String[][] groupResults = { { "a" }, { "a", "a" }, - { "ababababba", "a", "abb" }, { "ababababba", "a", "a", "b" }, - { "ababababba", "a", "a", "b", "b" }, - { "ababababba", "a", "a", "b", "abb", "b" }, }; - - for (int i = 0; i < groupPatterns.length; i++) { - Pattern test = Pattern.compile(groupPatterns[i]); - Matcher mat = test.matcher(positiveTestString); - mat.matches(); - for (int j = 0; j < groupResults[i].length; j++) { - assertEquals("i: " + i + " j: " + j, groupResults[i][j], mat - .group(j + 1)); - } - - } - - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies group() and group(int group) methods.", - method = "group", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies group() and group(int group) methods.", - method = "group", - args = {int.class} - ) - }) - public void testGroup() { - String positiveTestString = "ababababbaaabb"; - String negativeTestString = "gjhfgdsjfhgcbv"; - for (String element : groupPatterns) { - Pattern test = Pattern.compile(element); - Matcher mat = test.matcher(positiveTestString); - mat.matches(); - // test result - assertEquals(positiveTestString, mat.group()); - - // test equal to group(0) result - assertEquals(mat.group(0), mat.group()); - } - - for (String element : groupPatterns) { - Pattern test = Pattern.compile(element); - Matcher mat = test.matcher(negativeTestString); - mat.matches(); - try { - mat.group(); - fail("IllegalStateException expected for <false> matches result"); - } catch (IllegalStateException ise) { - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies group(int group) method.", - method = "group", - args = {int.class} - ) - public void testGroupPossessive() { - Pattern pat = Pattern.compile("((a)|(b))++c"); - Matcher mat = pat.matcher("aac"); - - mat.matches(); - assertEquals("a", mat.group(1)); - } - - /** - * @test java.util.regex.Matcher#hasAnchoringBounds() - * test hasAnchoringBounds() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies that hasAnchoringBounds method returns correct value.", - method = "hasAnchoringBounds", - args = {} - ) - public void test_hasAnchoringBounds() { - String testPattern = "abb"; - String testString = "abb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - assertTrue("Matcher uses anchoring bound by default", - mat.hasAnchoringBounds()); - - Matcher mu = mat.useAnchoringBounds(true); - assertTrue("Incorrect value of anchoring bounds", - mu.hasAnchoringBounds()); - - mu = mat.useAnchoringBounds(false); - assertFalse("Incorrect value of anchoring bounds", - mu.hasAnchoringBounds()); - } - - /** - * @test java.util.regex.Matcher#hasTransparentBounds() - * test hasTransparentBounds() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies that hasTransparentBound method returns correct value.", - method = "hasTransparentBounds", - args = {} - ) - public void test_hasTransparentBounds() { - String testPattern = "abb"; - String testString = "ab\nb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - assertFalse("Matcher uses opaque bounds by default", - mat.hasTransparentBounds()); - - Matcher mu = mat.useTransparentBounds(true); - assertTrue("Incorrect value of anchoring bounds", - mu.hasTransparentBounds()); - - mu = mat.useTransparentBounds(false); - assertFalse("Incorrect value of anchoring bounds", - mu.hasTransparentBounds()); - } - - /** - * @test java.util.regex.Matcher#start(int) - * test start(int) method. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the start(int group) method.", - method = "start", - args = {int.class} - ) - public void test_startI() { - String testPattern = "(((abb)a)(bb))"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - int i, j; - - for (j = 0; j < 3; j++) { - while (mat.find(start + j - 2)) { - for (i = 0; i < 4; i++) { - assertEquals("Start is wrong for group " + i + " :" + mat.group(i), start, mat.start(i)); - } - assertEquals("Start is wrong for group " + i + " :" + mat.group(i), start + 4, mat.start(i)); - - start = end; - end += 3; - } - } - } - - /** - * @test java.util.regex.Matcher#end(int) - * test end(int) method. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of end(int group) method.", - method = "end", - args = {int.class} - ) - public void test_endI() { - String testPattern = "(((abb)a)(bb))"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - int i, j; - - for (j = 0; j < 3; j++) { - while (mat.find(start + j - 2)) { - for (i = 0; i < 4; i++) { - assertEquals("End is wrong for group " + i + " :" + mat.group(i), start + mat.group(i).length(), mat.end(i)); - } - assertEquals("End is wrong for group " + i + " :" + mat.group(i), start + 4 + mat.group(i).length(), mat.end(i)); - - start = end; - end += 3; - } - } - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method in miscellaneous cases.", - method = "matches", - args = {} - ) - public void testMatchesMisc() { - String[][] posSeq = { - { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" }, - { "213567", "12324567", "1234567", "213213567", - "21312312312567", "444444567" }, - { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" }, - { "213234567", "3458", "0987654", "7689546432", "0398576", - "98432", "5" }, - { - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" }, - { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", - "abbbAbbbliceaaa", "Alice" }, - { "a123", "bnxnvgds156", "for", "while", "if", "struct" } - - }; - - for (int i = 0; i < testPatterns.length; i++) { - Pattern pat = Pattern.compile(testPatterns[i]); - for (int j = 0; j < posSeq[i].length; j++) { - Matcher mat = pat.matcher(posSeq[i][j]); - assertTrue("Incorrect match: " + testPatterns[i] + " vs " - + posSeq[i][j], mat.matches()); - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Stress test for matches() method.", - method = "matches", - args = {} - ) - public void testMatchesQuantifiers() { - String[] testPatternsSingles = { "a{5}", "a{2,4}", "a{3,}" }; - String[] testPatternsMultiple = { "((a)|(b)){1,2}abb", - "((a)|(b)){2,4}", "((a)|(b)){3,}" }; - - String[][] stringSingles = { { "aaaaa", "aaa" }, - { "aa", "a", "aaa", "aaaaaa", "aaaa", "aaaaa" }, - { "aaa", "a", "aaaa", "aa" }, }; - - String[][] stringMultiples = { { "ababb", "aba" }, - { "ab", "b", "bab", "ababa", "abba", "abababbb" }, - { "aba", "b", "abaa", "ba" }, }; - - for (int i = 0; i < testPatternsSingles.length; i++) { - Pattern pat = Pattern.compile(testPatternsSingles[i]); - for (int j = 0; j < stringSingles.length / 2; j++) { - assertTrue("Match expected, but failed: " + pat.pattern() - + " : " + stringSingles[i][j], pat.matcher( - stringSingles[i][j * 2]).matches()); - assertFalse("Match failure expected, but match succeed: " - + pat.pattern() + " : " + stringSingles[i][j * 2 + 1], - pat.matcher(stringSingles[i][j * 2 + 1]).matches()); - } - } - - for (int i = 0; i < testPatternsMultiple.length; i++) { - Pattern pat = Pattern.compile(testPatternsMultiple[i]); - for (int j = 0; j < stringMultiples.length / 2; j++) { - assertTrue("Match expected, but failed: " + pat.pattern() - + " : " + stringMultiples[i][j], pat.matcher( - stringMultiples[i][j * 2]).matches()); - assertFalse( - "Match failure expected, but match succeed: " - + pat.pattern() + " : " - + stringMultiples[i][j * 2 + 1], pat.matcher( - stringMultiples[i][j * 2 + 1]).matches()); - } - } - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "matches", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "group", - args = {int.class} - ) - }) - public void testQuantVsGroup() { - String patternString = "(d{1,3})((a|c)*)(d{1,3})((a|c)*)(d{1,3})"; - String testString = "dacaacaacaaddaaacaacaaddd"; - - Pattern pat = Pattern.compile(patternString); - Matcher mat = pat.matcher(testString); - - mat.matches(); - assertEquals("dacaacaacaaddaaacaacaaddd", mat.group()); - assertEquals("d", mat.group(1)); - assertEquals("acaacaacaa", mat.group(2)); - assertEquals("dd", mat.group(4)); - assertEquals("aaacaacaa", mat.group(5)); - assertEquals("ddd", mat.group(7)); - } - - /** - * @test java.util.regex.Matcher#lookingAt() - * test lookingAt() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies that lookingAt() method returns correct value.", - method = "lookingAt", - args = {} - ) - public void test_lookingAt() { - String testPattern = "(((abb)a)(bb))"; - String testString1 = "babbabbcccabbabbabbabbabb"; - String testString2 = "abbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat1 = pat.matcher(testString1); - Matcher mat2 = pat.matcher(testString2); - - assertFalse("Should not find given pattern in 1 string", mat1.lookingAt()); - mat1.region(1, 10); - assertTrue("Should find given pattern in region of string", mat1.lookingAt()); - assertTrue("Should find given pattern in 2 string", mat2.lookingAt()); - } - - /* - * Class under test for boolean find() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies that find() method returns correct value.", - method = "find", - args = {} - ) - public void testFind() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - while (mat.find()) { - assertEquals(start, mat.start(1)); - assertEquals(end, mat.end(1)); - - start = end; - end += 3; - } - - testPattern = "(\\d{1,3})"; - testString = "aaaa123456789045"; - - Pattern pat2 = Pattern.compile(testPattern); - Matcher mat2 = pat2.matcher(testString); - start = 4; - int length = 3; - while (mat2.find()) { - assertEquals(testString.substring(start, start + length), mat2 - .group(1)); - start += length; - } - } - - /** - * @test java.util.regex.Matcher#find(int) - * test find (int) method. Created via modifying method for find - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "find", - args = {int.class} - ) - public void test_findI() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - int j; - - for (j = 0; j < 3; j++) { - while (mat.find(start + j - 2)) { - assertEquals(start, mat.start(1)); - assertEquals(end, mat.end(1)); - - start = end; - end += 3; - } - start = 6; - end = 9; - } - - testPattern = "(\\d{1,3})"; - testString = "aaaa123456789045"; - - Pattern pat2 = Pattern.compile(testPattern); - Matcher mat2 = pat2.matcher(testString); - start = 4; - int length = 3; - for (j = 0; j < length; j++) { - for (int i = 4 + j; i < testString.length() - length; i += length) { - mat2.find(i); - assertEquals(testString.substring(i, i + length), mat2.group(1)); - } - } - - // Starting index out of region - Pattern pat3 = Pattern.compile("new"); - Matcher mat3 = pat3.matcher("Brave new world"); - - assertTrue(mat3.find(-1)); - assertTrue(mat3.find(6)); - assertFalse(mat3.find(7)); - - mat3.region(7, 10); - - assertFalse(mat3.find(3)); - assertFalse(mat3.find(6)); - assertFalse(mat3.find(7)); - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method for predefined.", - method = "replaceFirst", - args = {java.lang.String.class} - ) - public void testSEOLsymbols() { - Pattern pat = Pattern.compile("^a\\(bb\\[$"); - Matcher mat = pat.matcher("a(bb["); - - assertTrue(mat.matches()); - } - - /** - * @test java.util.regex.Matcher#start() - * test start() method. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the start() method.", - method = "start", - args = {} - ) - public void test_start() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - int j; - - for (j = 0; j < 3; j++) { - while (mat.find()) { - assertEquals("Start is wrong", start, mat.start()); - - start = end; - end += 3; - } - } - } - - /** - * @test java.util.regex.Matcher#end() - * test end() method. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of end() method. ", - method = "end", - args = {} - ) - public void test_end() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - int start = 3; - int end = 6; - int j; - - for (j = 0; j < 3; j++) { - while (mat.find()) { - assertEquals("Start is wrong", end, mat.end()); - - start = end; - end += 3; - } - } - } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies groupCount() method.", - method = "groupCount", - args = {} - ) - public void testGroupCount() { - for (int i = 0; i < groupPatterns.length; i++) { - Pattern test = Pattern.compile(groupPatterns[i]); - Matcher mat = test.matcher("ababababbaaabb"); - mat.matches(); - assertEquals(i + 1, mat.groupCount()); - } - } - - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "region", - args = {int.class, int.class} - ) - public void testRegion() { - Pattern p = Pattern.compile("abba"); - Matcher m = p.matcher("Gabba gabba hey"); - - m.region(0, 15); - assertTrue(m.find()); - assertTrue(m.find()); - assertFalse(m.find()); - - m.region(5, 15); - assertTrue(m.find()); - assertFalse(m.find()); - - m.region(10, 15); - assertFalse(m.find()); - - Throwable t = null; - - try { - m.region(-1, 15); - } catch (IllegalArgumentException e) { - t = e; - } - assertNotNull(t); - - t = null; - try { - m.region(0, 16); - } catch (IllegalArgumentException e) { - t = e; - } - assertNotNull(t); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "matches", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "group", - args = {int.class} - ) - }) - public void testRelactantQuantifiers() { - Pattern pat = Pattern.compile("(ab*)*b"); - Matcher mat = pat.matcher("abbbb"); - - if (mat.matches()) { - assertEquals("abbb", mat.group(1)); - } else { - fail("Match expected: (ab*)*b vs abbbb"); - } - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies find() method.", - method = "find", - args = {} - ) - public void testEnhancedFind() { - String input = "foob"; - String pattern = "a*b"; - Pattern pat = Pattern.compile(pattern); - Matcher mat = pat.matcher(input); - - mat.find(); - assertEquals("b", mat.group()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches method for input sequence specified by URL.", - method = "matches", - args = {} - ) - public void testMatchesURI() { - Pattern pat = Pattern. - compile("^(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?"); - Matcher mat = pat - .matcher("file:/c:/workspace/api/build.win32/classes/META-INF/" - + "services/javax.xml.parsers.DocumentBuilderFactory"); - assertTrue(mat.matches()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method for composite pattern groups.", - method = "matches", - args = {} - ) - public void testPosCompositeGroup() { - String[] posExamples = { "aabbcc", "aacc", "bbaabbcc" }; - String[] negExamples = { "aabb", "bb", "bbaabb" }; - Pattern posPat = Pattern.compile("(aa|bb){1,3}+cc"); - Pattern negPat = Pattern.compile("(aa|bb){1,3}+bb"); - - Matcher mat; - for (String element : posExamples) { - mat = posPat.matcher(element); - assertTrue(mat.matches()); - } - - for (String element : negExamples) { - mat = negPat.matcher(element); - assertFalse(mat.matches()); - } - - assertTrue(Pattern.matches("(aa|bb){1,3}+bb", "aabbaabb")); - - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method for specific patterns.", - method = "matches", - args = {} - ) - public void testPosAltGroup() { - String[] posExamples = { "aacc", "bbcc", "cc" }; - String[] negExamples = { "bb", "aa" }; - Pattern posPat = Pattern.compile("(aa|bb)?+cc"); - Pattern negPat = Pattern.compile("(aa|bb)?+bb"); - - Matcher mat; - for (String element : posExamples) { - mat = posPat.matcher(element); - assertTrue(posPat.toString() + " vs: " + element, mat.matches()); - } - - for (String element : negExamples) { - mat = negPat.matcher(element); - assertFalse(mat.matches()); - } - - assertTrue(Pattern.matches("(aa|bb)?+bb", "aabb")); - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "matches", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "group", - args = {int.class} - ) - }) - public void testRelCompGroup() { - - Matcher mat; - Pattern pat; - String res = ""; - for (int i = 0; i < 4; i++) { - pat = Pattern.compile("((aa|bb){" + i + ",3}?).*cc"); - mat = pat.matcher("aaaaaacc"); - assertTrue(pat.toString() + " vs: " + "aaaaaacc", mat.matches()); - assertEquals(res, mat.group(1)); - res += "aa"; - } - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "matches", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods for specific pattern.", - method = "group", - args = {int.class} - ) - }) - public void testRelAltGroup() { - - Matcher mat; - Pattern pat; - - pat = Pattern.compile("((aa|bb)??).*cc"); - mat = pat.matcher("aacc"); - assertTrue(pat.toString() + " vs: " + "aacc", mat.matches()); - assertEquals("", mat.group(1)); - - pat = Pattern.compile("((aa|bb)??)cc"); - mat = pat.matcher("aacc"); - assertTrue(pat.toString() + " vs: " + "aacc", mat.matches()); - assertEquals("aa", mat.group(1)); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method for case insensitive pattern.", - method = "matches", - args = {} - ) - public void testIgnoreCase() { - Pattern pat = Pattern.compile("(aa|bb)*", Pattern.CASE_INSENSITIVE); - Matcher mat = pat.matcher("aAbb"); - - assertTrue(mat.matches()); - - pat = Pattern.compile("(a|b|c|d|e)*", Pattern.CASE_INSENSITIVE); - mat = pat.matcher("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa"); - assertTrue(mat.matches()); - - pat = Pattern.compile("[a-e]*", Pattern.CASE_INSENSITIVE); - mat = pat.matcher("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa"); - assertTrue(mat.matches()); - - } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "quoteReplacement", - args = {java.lang.String.class} - ) - public void testQuoteReplacement() { - assertEquals("\\$dollar and slash\\\\", Matcher.quoteReplacement("$dollar and slash\\")); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods.", - method = "matches", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() and group(int group) methods.", - method = "group", - args = {int.class} - ) - }) - public void testOverFlow() { - Pattern tp = Pattern.compile("(a*)*"); - Matcher tm = tp.matcher("aaa"); - assertTrue(tm.matches()); - assertEquals("", tm.group(1)); - - assertTrue(Pattern.matches("(1+)\\1+", "11")); - assertTrue(Pattern.matches("(1+)(2*)\\2+", "11")); - - Pattern pat = Pattern.compile("(1+)\\1*"); - Matcher mat = pat.matcher("11"); - - assertTrue(mat.matches()); - assertEquals("11", mat.group(1)); - - pat = Pattern.compile("((1+)|(2+))(\\2+)"); - mat = pat.matcher("11"); - - assertTrue(mat.matches()); - assertEquals("1", mat.group(2)); - assertEquals("1", mat.group(1)); - assertEquals("1", mat.group(4)); - assertNull(mat.group(3)); - - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "matches", - args = {} - ) - public void testUnicode() { - - assertTrue(Pattern.compile("\\x61a").matcher("aa").matches()); -// assertTrue(Pattern.matches("\\u0061a", "aa")); - assertTrue(Pattern.compile("\\0141a").matcher("aa").matches()); - assertTrue(Pattern.compile("\\0777").matcher("?7").matches()); - - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "matches", - args = {} - ) - public void testUnicodeCategory() { - assertTrue(Pattern.compile("\\p{Ll}").matcher("k").matches()); // Unicode lower case - assertTrue(Pattern.compile("\\P{Ll}").matcher("K").matches()); // Unicode non-lower - // case - assertTrue(Pattern.compile("\\p{Lu}").matcher("K").matches()); // Unicode upper case - assertTrue(Pattern.compile("\\P{Lu}").matcher("k").matches()); // Unicode non-upper - // case - // combinations - assertTrue(Pattern.compile("[\\p{L}&&[^\\p{Lu}]]").matcher("k").matches()); - assertTrue(Pattern.compile("[\\p{L}&&[^\\p{Ll}]]").matcher("K").matches()); - assertFalse(Pattern.compile("[\\p{L}&&[^\\p{Lu}]]").matcher("K").matches()); - assertFalse(Pattern.compile("[\\p{L}&&[^\\p{Ll}]]").matcher("k").matches()); - - // category/character combinations - assertFalse(Pattern.compile("[\\p{L}&&[^a-z]]").matcher("k").matches()); - assertTrue(Pattern.compile("[\\p{L}&&[^a-z]]").matcher("K").matches()); - - assertTrue(Pattern.compile("[\\p{Lu}a-z]").matcher("k").matches()); - assertTrue(Pattern.compile("[a-z\\p{Lu}]").matcher("k").matches()); - - assertFalse(Pattern.compile("[\\p{Lu}a-d]").matcher("k").matches()); - assertTrue(Pattern.compile("[a-d\\p{Lu}]").matcher("K").matches()); - - // assertTrue(Pattern.matches("[\\p{L}&&[^\\p{Lu}&&[^K]]]", "K")); - assertFalse(Pattern.compile("[\\p{L}&&[^\\p{Lu}&&[^G]]]").matcher("K").matches()); - - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies that find() method works correctly with $ pattern.", - method = "find", - args = {} - ) - public void testFindDollar() { - Matcher mat = Pattern.compile("a$").matcher("a\n"); - assertTrue(mat.find()); - assertEquals("a", mat.group()); - } - - /* - * Verify if the Matcher can match the input when region is changed - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches() method for the specified region.", - method = "matches", - args = {} - ) - public void testMatchesRegionChanged() { - // Regression for HARMONY-610 - String input = " word "; - Pattern pattern = Pattern.compile("\\w+"); - Matcher matcher = pattern.matcher(input); - matcher.region(1, 5); - assertTrue(matcher.matches()); - } - - // BEGIN android-note - // Test took ages, now going in steps of 16 code points to speed things up. - // END android-note - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The stress test for matches(String regex) method from String class.", - clazz = String.class, - method = "matches", - args = {java.lang.String.class} - ) - public void testAllCodePoints() { - // Regression for HARMONY-3145 - int[] codePoint = new int[1]; - Pattern p = Pattern.compile("(\\p{all})+"); - boolean res = true; - int cnt = 0; - String s; - for (int i = 0; i < 0x110000; i = i + 0x10) { - codePoint[0] = i; - s = new String(codePoint, 0, 1); - if (!s.matches(p.toString())) { - cnt++; - res = false; - } - } - assertTrue(res); - assertEquals(0, cnt); - - p = Pattern.compile("(\\P{all})+"); - res = true; - cnt = 0; - - for (int i = 0; i < 0x110000; i = i + 0x10) { - codePoint[0] = i; - s = new String(codePoint, 0, 1); - if (!s.matches(p.toString())) { - cnt++; - res = false; - } - } - - assertFalse(res); - assertEquals(0x110000 / 0x10, cnt); - } - - /* - * Verify if the Matcher behaves correct when region is changed - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies find() method for specified region in positive case.", - method = "find", - args = {} - ) - public void testFindRegionChanged() { - // Regression for HARMONY-625 - Pattern pattern = Pattern.compile("(?s).*"); - Matcher matcher = pattern.matcher("abcde"); - matcher.find(); - assertEquals("abcde", matcher.group()); - - matcher = pattern.matcher("abcde"); - matcher.region(0, 2); - matcher.find(); - assertEquals("ab", matcher.group()); - - } - - /* - * Verify if the Matcher behaves correct with pattern "c" when region is - * changed - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies find() method for specified region in negative case.", - method = "find", - args = {} - ) - public void testFindRegionChanged2() { - // Regression for HARMONY-713 - Pattern pattern = Pattern.compile("c"); - - String inputStr = "aabb.c"; - Matcher matcher = pattern.matcher(inputStr); - matcher.region(0, 3); - - assertFalse(matcher.find()); - } - - /** - * @test java.util.regex.Matcher#regionStart() - * test regionStart() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the regionStart() method.", - method = "regionStart", - args = {} - ) - public void test_regionStart() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - assertEquals("Region sould start from 0 position", 0, mat.regionStart()); - mat.region(1, 10); - assertEquals("Region sould start from 1 position after setting new region", 1, mat.regionStart()); - mat.reset(); - assertEquals("Region sould start from 0 position after reset", 0, mat.regionStart()); - } - - /** - * @test java.util.regex.Matcher#regionEnd() - * test regionEnd() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the regionEnd() method.", - method = "regionEnd", - args = {} - ) - public void test_regionEnd() { - String testPattern = "(abb)"; - String testString = "cccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - assertEquals("Region end value should be equal to string length", testString.length(), mat.regionEnd()); - mat.region(1, 10); - assertEquals("Region end value should be equal to 10 after setting new region", 10, mat.regionEnd()); - mat.reset(); - assertEquals("Region end value should be equal to string length after reset", testString.length(), mat.regionEnd()); - } - - /** - * @test java.util.regex.Matcher#toMatchResult() - * test toMatchResult() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the toMatchResult method.", - method = "toMatchResult", - args = {} - ) - public void test_toMatchResult() { - String testPattern = "(((abb)a)(bb))"; - String testString = "babbabbcccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - mat.region(1, 7); - assertTrue("matcher should find pattern in given region", mat.matches()); - assertEquals("matched section should start from 1 position", 1, mat.toMatchResult().start()); - assertEquals("matched section for 2 group should start from 1 position", 1, mat.toMatchResult().start(2)); - assertEquals("matched section for whole pattern should end on 7 position", 7, mat.toMatchResult().end()); - assertEquals("matched section for 3 group should end at 4 position", 4, mat.toMatchResult().end(3)); - assertEquals("group not matched", "abbabb", mat.toMatchResult().group()); - assertEquals("3 group not matched", "abb", mat.toMatchResult().group(3)); - assertEquals("Total number of groups does not matched with given pattern", 4, mat.toMatchResult().groupCount()); - } - - /** - * @test java.util.regex.Matcher#usePattern(Pattern newPattern) - * test usePattern(Pattern newPattern) method. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the usePattern(Pattern newPattern) method.", - method = "usePattern", - args = {java.util.regex.Pattern.class} - ) - public void test_usePatternLjava_util_regex_Pattern() { - String testPattern1 = "(((abb)a)(bb))"; - String testPattern2 = "(abbabb)"; - String testPattern3 = "(babb)"; - String testString = "babbabbcccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern1); - Matcher mat = pat.matcher(testString); - - mat.region(1, 7); - assertTrue("matcher should find pattern in given region in case of groupe in pattern", mat.matches()); - assertEquals("", mat, mat.usePattern(Pattern.compile(testPattern2))); - assertTrue("matcher should find pattern in given region", mat.matches()); - assertEquals("", mat, mat.usePattern(Pattern.compile(testPattern3))); - assertFalse("matcher should not find pattern in given region", mat.matches()); - } - - /** - * @test java.util.regex.Matcher#useAchoringBounds() - * test useAchoringBounds() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "useAnchoringBounds", - args = {boolean.class} - ) - public void test_anchoringBounds() { - String testPattern = "^ro$"; - String testString = "android"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - mat.region(2, 5); - mat.useAnchoringBounds(false); - assertFalse("Shouldn't find pattern with non-anchoring bounds", mat.find(0)); - - mat.region(2, 5); - mat.useAnchoringBounds(true); - assertFalse("Should find pattern with anchoring bounds", mat.find(0)); - } - - /** - * @test java.util.regex.Matcher#useTransparentBounds() - * test useTransparentBounds() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the useTransparentBounds(boolean b) method.", - method = "useTransparentBounds", - args = {boolean.class} - ) - public void test_transparentBounds() { - String testPattern = "and(?=roid)"; - String testString = "android"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - mat.region(0, 3); - mat.useTransparentBounds(false); - assertFalse("Shouldn't find pattern with opaque bounds", mat.matches()); - - mat.useTransparentBounds(true); - assertTrue("Should find pattern transparent bounds", mat.matches()); // *** - - testPattern = "and(?!roid)"; - testString = "android"; - pat = Pattern.compile(testPattern); - mat = pat.matcher(testString); - - mat.region(0, 3); - mat.useTransparentBounds(false); - assertTrue("Should find pattern with opaque bounds", mat.matches()); - - mat.useTransparentBounds(true); - assertFalse("Shouldn't find pattern transparent bounds", mat.matches()); // *** - } - - /** - * @test java.util.regex.Matcher#hitEnd() - * test hitEnd() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies that hitEnd() method returns correct value. ", - method = "hitEnd", - args = {} - ) - public void test_hitEnd() { - String testPattern = "abb"; - String testString = "babbabbcccabbabbabbabbabb"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - while (mat.find()) { - assertFalse("hitEnd should return false during parsing input", mat.hitEnd()); - } - assertTrue("hitEnd should return true after finding last match", mat.hitEnd()); // *** - } - - /** - * @test java.util.regex.Matcher#requireEnd() - * test requireEnd() method. - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the requireEnd() method.", - method = "requireEnd", - args = {} - ) - public void test_requireEnd() { - String testPattern = "bba"; - String testString = "abbbbba"; - Pattern pat = Pattern.compile(testPattern); - Matcher mat = pat.matcher(testString); - - assertTrue(mat.find()); - assertFalse(mat.requireEnd()); - - testPattern = "bba$"; - testString = "abbbbba"; - pat = Pattern.compile(testPattern); - mat = pat.matcher(testString); - - assertTrue(mat.find()); - assertTrue(mat.requireEnd()); - } - - /* - * Regression test for HARMONY-674 - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Special regression test for matches() method.", - method = "matches", - args = {} - ) - public void testPatternMatcher() throws Exception { - Pattern pattern = Pattern.compile("(?:\\d+)(?:pt)"); - assertTrue(pattern.matcher("14pt").matches()); - } - - public static void main(String[] args) { - junit.textui.TestRunner.run(MatcherTest.class); - } - -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ModeTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ModeTest.java deleted file mode 100644 index bad03f7..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ModeTest.java +++ /dev/null @@ -1,150 +0,0 @@ -/* 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import junit.framework.TestCase; -import java.util.regex.Pattern; -import java.util.regex.Matcher; -import java.util.regex.PatternSyntaxException; - -/** - * Tests Pattern compilation modes and modes triggered in pattern strings - * - */ -@TestTargetClass(Pattern.class) -public class ModeTest extends TestCase { - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies compile(String regex) and compile(String regex, int flags) methods with Pattern.CASE_INSENSITIVE mode.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies compile(String regex) and compile(String regex, int flags) methods with Pattern.CASE_INSENSITIVE mode.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testCase() throws PatternSyntaxException { - Pattern p; - Matcher m; - - p = Pattern.compile("([a-z]+)[0-9]+"); - m = p.matcher("cAT123#dog345"); - assertTrue(m.find()); - assertEquals("dog", m.group(1)); - assertFalse(m.find()); - - - p = Pattern.compile("([a-z]+)[0-9]+", Pattern.CASE_INSENSITIVE); - m = p.matcher("cAt123#doG345"); - assertTrue(m.find()); - assertEquals("cAt", m.group(1)); - assertTrue(m.find()); - assertEquals("doG", m.group(1)); - assertFalse(m.find()); - - - p = Pattern.compile("(?i)([a-z]+)[0-9]+"); - m = p.matcher("cAt123#doG345"); - assertTrue(m.find()); - assertEquals("cAt", m.group(1)); - assertTrue(m.find()); - assertEquals("doG", m.group(1)); - assertFalse(m.find()); - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies compile(String regex) and compile(String regex, int flags) methods with Pattern.MULTILINE mode.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies compile(String regex) and compile(String regex, int flags) methods with Pattern.MULTILINE mode.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testMultiline() throws PatternSyntaxException { - Pattern p; - Matcher m; - - p = Pattern.compile("^foo"); - m = p.matcher("foobar"); - assertTrue(m.find()); - assertTrue(m.start() == 0 && m.end() == 3); - assertFalse(m.find()); - - m = p.matcher("barfoo"); - assertFalse(m.find()); - - - p = Pattern.compile("foo$"); - m = p.matcher("foobar"); - assertFalse(m.find()); - - m = p.matcher("barfoo"); - assertTrue(m.find()); - assertTrue(m.start() == 3 && m.end() == 6); - assertFalse(m.find()); - - - p = Pattern.compile("^foo([0-9]*)", Pattern.MULTILINE); - m = p.matcher("foo1bar\nfoo2foo3\nbarfoo4"); - assertTrue(m.find()); - assertEquals("1", m.group(1)); - assertTrue(m.find()); - assertEquals("2", m.group(1)); - assertFalse(m.find()); - - - p = Pattern.compile("foo([0-9]*)$", Pattern.MULTILINE); - m = p.matcher("foo1bar\nfoo2foo3\nbarfoo4"); - assertTrue(m.find()); - assertEquals("3", m.group(1)); - assertTrue(m.find()); - assertEquals("4", m.group(1)); - assertFalse(m.find()); - - - p = Pattern.compile("(?m)^foo([0-9]*)"); - m = p.matcher("foo1bar\nfoo2foo3\nbarfoo4"); - assertTrue(m.find()); - assertEquals("1", m.group(1)); - assertTrue(m.find()); - assertEquals("2", m.group(1)); - assertFalse(m.find()); - - p = Pattern.compile("(?m)foo([0-9]*)$"); - m = p.matcher("foo1bar\nfoo2foo3\nbarfoo4"); - assertTrue(m.find()); - assertEquals("3", m.group(1)); - assertTrue(m.find()); - assertEquals("4", m.group(1)); - assertFalse(m.find()); - } -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Pattern2Test.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Pattern2Test.java deleted file mode 100644 index 10d2534..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/Pattern2Test.java +++ /dev/null @@ -1,1611 +0,0 @@ -/* 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.BrokenTest; -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.regex.PatternSyntaxException; - -import junit.framework.TestCase; -@TestTargetClass(Pattern.class) -/** - * Tests simple Pattern compilation and Matcher methods - * - */ -public class Pattern2Test extends TestCase { - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matches(String regex, CharSequence input) method.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testSimpleMatch() throws PatternSyntaxException { - Pattern p = Pattern.compile("foo.*"); - - Matcher m1 = p.matcher("foo123"); - assertTrue(m1.matches()); - assertTrue(m1.find(0)); - assertTrue(m1.lookingAt()); - - Matcher m2 = p.matcher("fox"); - assertFalse(m2.matches()); - assertFalse(m2.find(0)); - assertFalse(m2.lookingAt()); - - assertTrue(Pattern.matches("foo.*", "foo123")); - assertFalse(Pattern.matches("foo.*", "fox")); - - assertFalse(Pattern.matches("bar", "foobar")); - - assertTrue(Pattern.matches("", "")); - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testCursors() { - Pattern p; - Matcher m; - - try { - p = Pattern.compile("foo"); - - m = p.matcher("foobar"); - assertTrue(m.find()); - assertEquals(0, m.start()); - assertEquals(3, m.end()); - assertFalse(m.find()); - - // Note: also testing reset here - m.reset(); - assertTrue(m.find()); - assertEquals(0, m.start()); - assertEquals(3, m.end()); - assertFalse(m.find()); - - m.reset("barfoobar"); - assertTrue(m.find()); - assertEquals(3, m.start()); - assertEquals(6, m.end()); - assertFalse(m.find()); - - m.reset("barfoo"); - assertTrue(m.find()); - assertEquals(3, m.start()); - assertEquals(6, m.end()); - assertFalse(m.find()); - - m.reset("foobarfoobarfoo"); - assertTrue(m.find()); - assertEquals(0, m.start()); - assertEquals(3, m.end()); - assertTrue(m.find()); - assertEquals(6, m.start()); - assertEquals(9, m.end()); - assertTrue(m.find()); - assertEquals(12, m.start()); - assertEquals(15, m.end()); - assertFalse(m.find()); - assertTrue(m.find(0)); - assertEquals(0, m.start()); - assertEquals(3, m.end()); - assertTrue(m.find(4)); - assertEquals(6, m.start()); - assertEquals(9, m.end()); - } catch (PatternSyntaxException e) { - System.out.println(e.getMessage()); - fail(); - } - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testGroups() throws PatternSyntaxException { - Pattern p; - Matcher m; - - p = Pattern.compile("(p[0-9]*)#?(q[0-9]*)"); - - m = p.matcher("p1#q3p2q42p5p71p63#q888"); - assertTrue(m.find()); - assertEquals(0, m.start()); - assertEquals(5, m.end()); - assertEquals(2, m.groupCount()); - assertEquals(0, m.start(0)); - assertEquals(5, m.end(0)); - assertEquals(0, m.start(1)); - assertEquals(2, m.end(1)); - assertEquals(3, m.start(2)); - assertEquals(5, m.end(2)); - assertEquals("p1#q3", m.group()); - assertEquals("p1#q3", m.group(0)); - assertEquals("p1", m.group(1)); - assertEquals("q3", m.group(2)); - - assertTrue(m.find()); - assertEquals(5, m.start()); - assertEquals(10, m.end()); - assertEquals(2, m.groupCount()); - assertEquals(10, m.end(0)); - assertEquals(5, m.start(1)); - assertEquals(7, m.end(1)); - assertEquals(7, m.start(2)); - assertEquals(10, m.end(2)); - assertEquals("p2q42", m.group()); - assertEquals("p2q42", m.group(0)); - assertEquals("p2", m.group(1)); - assertEquals("q42", m.group(2)); - - assertTrue(m.find()); - assertEquals(15, m.start()); - assertEquals(23, m.end()); - assertEquals(2, m.groupCount()); - assertEquals(15, m.start(0)); - assertEquals(23, m.end(0)); - assertEquals(15, m.start(1)); - assertEquals(18, m.end(1)); - assertEquals(19, m.start(2)); - assertEquals(23, m.end(2)); - assertEquals("p63#q888", m.group()); - assertEquals("p63#q888", m.group(0)); - assertEquals("p63", m.group(1)); - assertEquals("q888", m.group(2)); - assertFalse(m.find()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testReplace() throws PatternSyntaxException { - Pattern p; - Matcher m; - - // Note: examples from book, - // Hitchens, Ron, 2002, "Java NIO", O'Reilly, page 171 - p = Pattern.compile("a*b"); - - m = p.matcher("aabfooaabfooabfoob"); - assertTrue(m.replaceAll("-").equals("-foo-foo-foo-")); - assertTrue(m.replaceFirst("-").equals("-fooaabfooabfoob")); - - /* - * p = Pattern.compile ("\\p{Blank}"); - * - * m = p.matcher ("fee fie foe fum"); assertTrue - * (m.replaceFirst("-").equals ("fee-fie foe fum")); assertTrue - * (m.replaceAll("-").equals ("fee-fie-foe-fum")); - */ - - p = Pattern.compile("([bB])yte"); - - m = p.matcher("Byte for byte"); - assertTrue(m.replaceFirst("$1ite").equals("Bite for byte")); - assertTrue(m.replaceAll("$1ite").equals("Bite for bite")); - - p = Pattern.compile("\\d\\d\\d\\d([- ])"); - - m = p.matcher("card #1234-5678-1234"); - assertTrue(m.replaceFirst("xxxx$1").equals("card #xxxx-5678-1234")); - assertTrue(m.replaceAll("xxxx$1").equals("card #xxxx-xxxx-1234")); - - p = Pattern.compile("(up|left)( *)(right|down)"); - - m = p.matcher("left right, up down"); - assertTrue(m.replaceFirst("$3$2$1").equals("right left, up down")); - assertTrue(m.replaceAll("$3$2$1").equals("right left, down up")); - - p = Pattern.compile("([CcPp][hl]e[ea]se)"); - - m = p.matcher("I want cheese. Please."); - assertTrue(m.replaceFirst("<b> $1 </b>").equals( - "I want <b> cheese </b>. Please.")); - assertTrue(m.replaceAll("<b> $1 </b>").equals( - "I want <b> cheese </b>. <b> Please </b>.")); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testEscapes() throws PatternSyntaxException { - Pattern p; - Matcher m; - - // Test \\ sequence - p = Pattern.compile("([a-z]+)\\\\([a-z]+);"); - m = p.matcher("fred\\ginger;abbott\\costello;jekell\\hyde;"); - assertTrue(m.find()); - assertEquals("fred", m.group(1)); - assertEquals("ginger", m.group(2)); - assertTrue(m.find()); - assertEquals("abbott", m.group(1)); - assertEquals("costello", m.group(2)); - assertTrue(m.find()); - assertEquals("jekell", m.group(1)); - assertEquals("hyde", m.group(2)); - assertFalse(m.find()); - - // Test \n, \t, \r, \f, \e, \a sequences - p = Pattern.compile("([a-z]+)[\\n\\t\\r\\f\\e\\a]+([a-z]+)"); - m = p.matcher("aa\nbb;cc\u0009\rdd;ee\u000C\u001Bff;gg\n\u0007hh"); - assertTrue(m.find()); - assertEquals("aa", m.group(1)); - assertEquals("bb", m.group(2)); - assertTrue(m.find()); - assertEquals("cc", m.group(1)); - assertEquals("dd", m.group(2)); - assertTrue(m.find()); - assertEquals("ee", m.group(1)); - assertEquals("ff", m.group(2)); - assertTrue(m.find()); - assertEquals("gg", m.group(1)); - assertEquals("hh", m.group(2)); - assertFalse(m.find()); - - // Test \\u and \\x sequences -/* p = Pattern.compile("([0-9]+)[\\u0020:\\x21];"); - m = p.matcher("11:;22 ;33-;44!;"); - assertTrue(m.find()); - assertEquals("11", m.group(1)); - assertTrue(m.find()); - assertEquals("22", m.group(1)); - assertTrue(m.find()); - assertEquals("44", m.group(1)); - assertFalse(m.find()); -*/ - // Test invalid unicode sequences -/* try { - p = Pattern.compile("\\u"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\u;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\u002"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\u002;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - // Test invalid hex sequences - try { - p = Pattern.compile("\\x"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\x;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\xa"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\xa;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } -*/ - // Test \0 (octal) sequences (1, 2 and 3 digit) - p = Pattern.compile("([0-9]+)[\\07\\040\\0160];"); - m = p.matcher("11\u0007;22:;33 ;44p;"); - assertTrue(m.find()); - assertEquals("11", m.group(1)); - assertTrue(m.find()); - assertEquals("33", m.group(1)); - assertTrue(m.find()); - assertEquals("44", m.group(1)); - assertFalse(m.find()); - - // Test invalid octal sequences - try { - p = Pattern.compile("\\08"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - //originally contributed test did not check the result - //TODO: check what RI does here -// try { -// p = Pattern.compile("\\0477"); -// fail("PatternSyntaxException expected"); -// } catch (PatternSyntaxException e) { -// } - - try { - p = Pattern.compile("\\0"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\0;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - - // Test \c (control character) sequence - p = Pattern.compile("([0-9]+)[\\cA\\cB\\cC\\cD];"); - m = p.matcher("11\u0001;22:;33\u0002;44p;55\u0003;66\u0004;"); - assertTrue(m.find()); - assertEquals("11", m.group(1)); - assertTrue(m.find()); - assertEquals("33", m.group(1)); - assertTrue(m.find()); - assertEquals("55", m.group(1)); - assertTrue(m.find()); - assertEquals("66", m.group(1)); - assertFalse(m.find()); - - // More thorough control escape test - // Ensure that each escape matches exactly the corresponding - // character - // code and no others (well, from 0-255 at least) - int i, j; - for (i = 0; i < 26; i++) { - p = Pattern.compile("\\c" + Character.toString((char) ('A' + i))); - int match_char = -1; - for (j = 0; j < 255; j++) { - m = p.matcher(Character.toString((char) j)); - if (m.matches()) { - assertEquals(-1, match_char); - match_char = j; - } - } - assertTrue(match_char == i + 1); - } - - // Test invalid control escapes -// BEGIN android-removed -// ICU doesn't complain about illegal control sequences -// try { -// p = Pattern.compile("\\c"); -// fail("PatternSyntaxException expected"); -// } catch (PatternSyntaxException e) { -// } -// END android-removed - - //originally contributed test did not check the result - //TODO: check what RI does here -// try { -// p = Pattern.compile("\\c;"); -// fail("PatternSyntaxException expected"); -// } catch (PatternSyntaxException e) { -// } -// -// try { -// p = Pattern.compile("\\ca;"); -// fail("PatternSyntaxException expected"); -// } catch (PatternSyntaxException e) { -// } -// -// try { -// p = Pattern.compile("\\c4;"); -// fail("PatternSyntaxException expected"); -// } catch (PatternSyntaxException e) { -// } - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies patterns with different ranges of characters.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies patterns with different ranges of characters.", - method = "matcher", - args = {CharSequence.class} - ) - }) - public void testCharacterClasses() throws PatternSyntaxException { - Pattern p; - Matcher m; - - // Test one character range - p = Pattern.compile("[p].*[l]"); - m = p.matcher("paul"); - assertTrue(m.matches()); - m = p.matcher("pool"); - assertTrue(m.matches()); - m = p.matcher("pong"); - assertFalse(m.matches()); - m = p.matcher("pl"); - assertTrue(m.matches()); - - // Test two character range - p = Pattern.compile("[pm].*[lp]"); - m = p.matcher("prop"); - assertTrue(m.matches()); - m = p.matcher("mall"); - assertTrue(m.matches()); - m = p.matcher("pong"); - assertFalse(m.matches()); - m = p.matcher("pill"); - assertTrue(m.matches()); - - // Test range including [ and ] - p = Pattern.compile("[<\\[].*[\\]>]"); - m = p.matcher("<foo>"); - assertTrue(m.matches()); - m = p.matcher("[bar]"); - assertTrue(m.matches()); - m = p.matcher("{foobar]"); - assertFalse(m.matches()); - m = p.matcher("<pill]"); - assertTrue(m.matches()); - - // Test range using ^ - p = Pattern.compile("[^bc][a-z]+[tr]"); - m = p.matcher("pat"); - assertTrue(m.matches()); - m = p.matcher("liar"); - assertTrue(m.matches()); - m = p.matcher("car"); - assertFalse(m.matches()); - m = p.matcher("gnat"); - assertTrue(m.matches()); - - // Test character range using - - p = Pattern.compile("[a-z]_+[a-zA-Z]-+[0-9p-z]"); - m = p.matcher("d__F-8"); - assertTrue(m.matches()); - m = p.matcher("c_a-q"); - assertTrue(m.matches()); - m = p.matcher("a__R-a"); - assertFalse(m.matches()); - m = p.matcher("r_____d-----5"); - assertTrue(m.matches()); - - // Test range using unicode characters and unicode and hex escapes - p = Pattern.compile("[\\u1234-\\u2345]_+[a-z]-+[\u0001-\\x11]"); - m = p.matcher("\u2000_q-\u0007"); - assertTrue(m.matches()); - m = p.matcher("\u1234_z-\u0001"); - assertTrue(m.matches()); - m = p.matcher("r_p-q"); - assertFalse(m.matches()); - m = p.matcher("\u2345_____d-----\n"); - assertTrue(m.matches()); - -// BEGIN android-removed -// The "---" collides with ICU's "--" operator and is likely to be a user error -// anyway, so we simply comment this one out. -// // Test ranges including the "-" character -// p = Pattern.compile("[\\*-/]_+[---]!+[--AP]"); -// m = p.matcher("-_-!!A"); -// assertTrue(m.matches()); -// m = p.matcher("\u002b_-!!!-"); -// assertTrue(m.matches()); -// m = p.matcher("!_-!@"); -// assertFalse(m.matches()); -// m = p.matcher(",______-!!!!!!!P"); -// assertTrue(m.matches()); -// END android-removed - - // Test nested ranges - p = Pattern.compile("[pm[t]][a-z]+[[r]lp]"); - m = p.matcher("prop"); - assertTrue(m.matches()); - m = p.matcher("tsar"); - assertTrue(m.matches()); - m = p.matcher("pong"); - assertFalse(m.matches()); - m = p.matcher("moor"); - assertTrue(m.matches()); - - // Test character class intersection with && - // TODO: figure out what x&&y or any class with a null intersection - // set (like [[a-c]&&[d-f]]) might mean. It doesn't mean "match - // nothing" and doesn't mean "match anything" so I'm stumped. - p = Pattern.compile("[[a-p]&&[g-z]]+-+[[a-z]&&q]-+[x&&[a-z]]-+"); - m = p.matcher("h--q--x--"); - assertTrue(m.matches()); - m = p.matcher("hog--q-x-"); - assertTrue(m.matches()); - m = p.matcher("ape--q-x-"); - assertFalse(m.matches()); - m = p.matcher("mop--q-x----"); - assertTrue(m.matches()); - - // Test error cases with && -// BEGIN android-removed -// This is more of a bug, and ICU doesn't have this behavior. -// p = Pattern.compile("[&&[xyz]]"); -// m = p.matcher("&"); -// // System.out.println(m.matches()); -// m = p.matcher("x"); -// // System.out.println(m.matches()); -// m = p.matcher("y"); -// // System.out.println(m.matches()); -// END android-removed - p = Pattern.compile("[[xyz]&[axy]]"); - m = p.matcher("x"); - // System.out.println(m.matches()); - m = p.matcher("z"); - // System.out.println(m.matches()); - m = p.matcher("&"); - // System.out.println(m.matches()); - p = Pattern.compile("[abc[123]&&[345]def]"); - m = p.matcher("a"); - // System.out.println(m.matches()); - -// BEGIN android-removed -// This is more of a bug, and ICU doesn't have this behavior. -// p = Pattern.compile("[[xyz]&&]"); -// END android-removed - p = Pattern.compile("[[abc]&]"); - - try { - p = Pattern.compile("[[abc]&&"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - p = Pattern.compile("[[abc]\\&&[xyz]]"); - - p = Pattern.compile("[[abc]&\\&[xyz]]"); - - // Test 3-way intersection - p = Pattern.compile("[[a-p]&&[g-z]&&[d-k]]"); - m = p.matcher("g"); - assertTrue(m.matches()); - m = p.matcher("m"); - assertFalse(m.matches()); - - // Test nested intersection - p = Pattern.compile("[[[a-p]&&[g-z]]&&[d-k]]"); - m = p.matcher("g"); - assertTrue(m.matches()); - m = p.matcher("m"); - assertFalse(m.matches()); - - // Test character class subtraction with && and ^ - p = Pattern.compile("[[a-z]&&[^aeiou]][aeiou][[^xyz]&&[a-z]]"); - m = p.matcher("pop"); - assertTrue(m.matches()); - m = p.matcher("tag"); - assertTrue(m.matches()); - m = p.matcher("eat"); - assertFalse(m.matches()); - m = p.matcher("tax"); - assertFalse(m.matches()); - m = p.matcher("zip"); - assertTrue(m.matches()); - - // Test . (DOT), with and without DOTALL - // Note: DOT not allowed in character classes - p = Pattern.compile(".+/x.z"); - m = p.matcher("!$/xyz"); - assertTrue(m.matches()); - m = p.matcher("%\n\r/x\nz"); - assertFalse(m.matches()); - p = Pattern.compile(".+/x.z", Pattern.DOTALL); - m = p.matcher("%\n\r/x\nz"); - assertTrue(m.matches()); - - // Test \d (digit) - p = Pattern.compile("\\d+[a-z][\\dx]"); - m = p.matcher("42a6"); - assertTrue(m.matches()); - m = p.matcher("21zx"); - assertTrue(m.matches()); - m = p.matcher("ab6"); - assertFalse(m.matches()); - m = p.matcher("56912f9"); - assertTrue(m.matches()); - - // Test \D (not a digit) - p = Pattern.compile("\\D+[a-z]-[\\D3]"); - m = p.matcher("za-p"); - assertTrue(m.matches()); - m = p.matcher("%!e-3"); - assertTrue(m.matches()); - m = p.matcher("9a-x"); - assertFalse(m.matches()); - m = p.matcher("\u1234pp\ny-3"); - assertTrue(m.matches()); - - // Test \s (whitespace) - p = Pattern.compile("<[a-zA-Z]+\\s+[0-9]+[\\sx][^\\s]>"); - m = p.matcher("<cat \t1\fx>"); - assertTrue(m.matches()); - m = p.matcher("<cat \t1\f >"); - assertFalse(m.matches()); - m = p - .matcher("xyz <foo\n\r22 5> <pp \t\n\f\r \u000b41x\u1234><pp \nx7\rc> zzz"); - assertTrue(m.find()); - assertTrue(m.find()); - assertFalse(m.find()); - - // Test \S (not whitespace) - p = Pattern.compile("<[a-z] \\S[0-9][\\S\n]+[^\\S]221>"); - m = p.matcher("<f $0**\n** 221>"); - assertTrue(m.matches()); - m = p.matcher("<x 441\t221>"); - assertTrue(m.matches()); - m = p.matcher("<z \t9\ng 221>"); - assertFalse(m.matches()); - m = p.matcher("<z 60\ngg\u1234\f221>"); - assertTrue(m.matches()); - p = Pattern.compile("<[a-z] \\S[0-9][\\S\n]+[^\\S]221[\\S&&[^abc]]>"); - m = p.matcher("<f $0**\n** 221x>"); - assertTrue(m.matches()); - m = p.matcher("<x 441\t221z>"); - assertTrue(m.matches()); - m = p.matcher("<x 441\t221 >"); - assertFalse(m.matches()); - m = p.matcher("<x 441\t221c>"); - assertFalse(m.matches()); - m = p.matcher("<z \t9\ng 221x>"); - assertFalse(m.matches()); - m = p.matcher("<z 60\ngg\u1234\f221\u0001>"); - assertTrue(m.matches()); - - // Test \w (ascii word) - p = Pattern.compile("<\\w+\\s[0-9]+;[^\\w]\\w+/[\\w$]+;"); - m = p.matcher("<f1 99;!foo5/a$7;"); - assertTrue(m.matches()); - m = p.matcher("<f$ 99;!foo5/a$7;"); - assertFalse(m.matches()); - m = p - .matcher("<abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 99;!foo5/a$7;"); - assertTrue(m.matches()); - - // Test \W (not an ascii word) - p = Pattern.compile("<\\W\\w+\\s[0-9]+;[\\W_][^\\W]+\\s[0-9]+;"); - m = p.matcher("<$foo3\n99;_bar\t0;"); - assertTrue(m.matches()); - m = p.matcher("<hh 99;_g 0;"); - assertFalse(m.matches()); - m = p.matcher("<*xx\t00;^zz\f11;"); - assertTrue(m.matches()); - - // Test x|y pattern - // TODO - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for patterns with POSIX characters.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for patterns with POSIX characters.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testPOSIXGroups() throws PatternSyntaxException { - Pattern p; - Matcher m; - - // Test POSIX groups using \p and \P (in the group and not in the group) - // Groups are Lower, Upper, ASCII, Alpha, Digit, XDigit, Alnum, Punct, - // Graph, Print, Blank, Space, Cntrl - // Test \p{Lower} - /* - * FIXME: Requires complex range processing - * p = Pattern.compile("<\\p{Lower}\\d\\P{Lower}:[\\p{Lower}Z]\\s[^\\P{Lower}]>"); - * m = p.matcher("<a4P:g x>"); assertTrue(m.matches()); m = - * p.matcher("<p4%:Z\tq>"); assertTrue(m.matches()); m = - * p.matcher("<A6#:e e>"); assertFalse(m.matches()); - */ - p = Pattern.compile("\\p{Lower}+"); - m = p.matcher("abcdefghijklmnopqrstuvwxyz"); - assertTrue(m.matches()); - - // Invalid uses of \p{Lower} - try { - p = Pattern.compile("\\p"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{Lower"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{Lower;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - // Test \p{Upper} - /* - * FIXME: Requires complex range processing - * p = Pattern.compile("<\\p{Upper}\\d\\P{Upper}:[\\p{Upper}z]\\s[^\\P{Upper}]>"); - * m = p.matcher("<A4p:G X>"); assertTrue(m.matches()); m = - * p.matcher("<P4%:z\tQ>"); assertTrue(m.matches()); m = - * p.matcher("<a6#:E E>"); assertFalse(m.matches()); - */ - p = Pattern.compile("\\p{Upper}+"); - m = p.matcher("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); - assertTrue(m.matches()); - - // Invalid uses of \p{Upper} - try { - p = Pattern.compile("\\p{Upper"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{Upper;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - // Test \p{ASCII} - /* - * FIXME: Requires complex range processing p = Pattern.compile("<\\p{ASCII}\\d\\P{ASCII}:[\\p{ASCII}\u1234]\\s[^\\P{ASCII}]>"); - * m = p.matcher("<A4\u0080:G X>"); assertTrue(m.matches()); m = - * p.matcher("<P4\u00ff:\u1234\t\n>"); assertTrue(m.matches()); m = - * p.matcher("<\u00846#:E E>"); assertFalse(m.matches()) - */ - int i; - p = Pattern.compile("\\p{ASCII}"); - for (i = 0; i < 0x80; i++) { - m = p.matcher(Character.toString((char) i)); - assertTrue(m.matches()); - } - for (; i < 0xff; i++) { - m = p.matcher(Character.toString((char) i)); - assertFalse(m.matches()); - } - - // Invalid uses of \p{ASCII} - try { - p = Pattern.compile("\\p{ASCII"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - try { - p = Pattern.compile("\\p{ASCII;"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException e) { - } - - // Test \p{Alpha} - // TODO - - // Test \p{Digit} - // TODO - - // Test \p{XDigit} - // TODO - - // Test \p{Alnum} - // TODO - - // Test \p{Punct} - // TODO - - // Test \p{Graph} - // TODO - - // Test \p{Print} - // TODO - - // Test \p{Blank} - // TODO - - // Test \p{Space} - // TODO - - // Test \p{Cntrl} - // TODO - } - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "TODO empty test", - method = "!", - args = {} - ) - @BrokenTest("empty test") - public void testUnicodeCategories() throws PatternSyntaxException { - // Test Unicode categories using \p and \P - // One letter codes: L, M, N, P, S, Z, C - // Two letter codes: Lu, Nd, Sc, Sm, ... - // See java.lang.Character and Unicode standard for complete list - // TODO - // Test \p{L} - // TODO - - // Test \p{N} - // TODO - - // ... etc - - // Test two letter codes: - // From unicode.org: - // Lu - // Ll - // Lt - // Lm - // Lo - // Mn - // Mc - // Me - // Nd - // Nl - // No - // Pc - // Pd - // Ps - // Pe - // Pi - // Pf - // Po - // Sm - // Sc - // Sk - // So - // Zs - // Zl - // Zp - // Cc - // Cf - // Cs - // Co - // Cn - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies matcher(CharSequence input) method for input specified by Unicode blocks.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - public void testUnicodeBlocks() throws PatternSyntaxException { - Pattern p; - Matcher m; - int i, j; - - // Test Unicode blocks using \p and \P - // FIXME: - // Note that LatinExtended-B and ArabicPresentations-B are unrecognized - // by the reference JDK. - for (i = 0; i < UBlocks.length; i++) { - /* - * p = Pattern.compile("\\p{"+UBlocks[i].name+"}"); - * - * if (UBlocks[i].low > 0) { m = - * p.matcher(Character.toString((char)(UBlocks[i].low-1))); - * assertFalse(m.matches()); } for (j=UBlocks[i].low; j <= - * UBlocks[i].high; j++) { m = - * p.matcher(Character.toString((char)j)); - * assertTrue(m.matches()); } if (UBlocks[i].high < 0xFFFF) { m = - * p.matcher(Character.toString((char)(UBlocks[i].high+1))); - * assertFalse(m.matches()); } - * - * p = Pattern.compile("\\P{"+UBlocks[i].name+"}"); - * - * if (UBlocks[i].low > 0) { m = - * p.matcher(Character.toString((char)(UBlocks[i].low-1))); - * assertTrue(m.matches()); } for (j=UBlocks[i].low; j < - * UBlocks[i].high; j++) { m = - * p.matcher(Character.toString((char)j)); - * assertFalse(m.matches()); } if (UBlocks[i].high < 0xFFFF) { m = - * p.matcher(Character.toString((char)(UBlocks[i].high+1))); - * assertTrue(m.matches()); } - */ - - p = Pattern.compile("\\p{In" + UBlocks[i].name + "}"); -// BEGIN android-changed -// Added the name of the block under test to the assertion to get more output. - - if (UBlocks[i].low > 0) { - m = p.matcher(Character.toString((char) (UBlocks[i].low - 1))); - assertFalse(UBlocks[i].name, m.matches()); - } - for (j = UBlocks[i].low; j <= UBlocks[i].high; j++) { - m = p.matcher(Character.toString((char) j)); - assertTrue(UBlocks[i].name, m.matches()); - } - if (UBlocks[i].high < 0xFFFF) { - m = p.matcher(Character.toString((char) (UBlocks[i].high + 1))); - assertFalse(UBlocks[i].name, m.matches()); - } - - p = Pattern.compile("\\P{In" + UBlocks[i].name + "}"); - - if (UBlocks[i].low > 0) { - m = p.matcher(Character.toString((char) (UBlocks[i].low - 1))); - assertTrue(UBlocks[i].name, m.matches()); - } - for (j = UBlocks[i].low; j < UBlocks[i].high; j++) { - m = p.matcher(Character.toString((char) j)); - assertFalse(UBlocks[i].name, m.matches()); - } - if (UBlocks[i].high < 0xFFFF) { - m = p.matcher(Character.toString((char) (UBlocks[i].high + 1))); - assertTrue(UBlocks[i].name, m.matches()); - } - -// END android-changed - } - } - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "TODO empty test", - method = "!", - args = {} - ) - @BrokenTest("empty test") - public void testCapturingGroups() throws PatternSyntaxException { - // Test simple capturing groups - // TODO - - // Test grouping without capture (?:...) - // TODO - - // Test combination of grouping and capture - // TODO - - // Test \<num> sequence with capturing and non-capturing groups - // TODO - - // Test \<num> with <num> out of range - // TODO - } - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "TODO empty test", - method = "!", - args = {} - ) - @BrokenTest("empty test") - public void testRepeats() { - // Test ? - // TODO - - // Test * - // TODO - - // Test + - // TODO - - // Test {<num>}, including 0, 1 and more - // TODO - - // Test {<num>,}, including 0, 1 and more - // TODO - - // Test {<n1>,<n2>}, with n1 < n2, n1 = n2 and n1 > n2 (illegal?) - // TODO - } - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "TODO empty test", - method = "!", - args = {} - ) - @BrokenTest("empty test") - public void testAnchors() throws PatternSyntaxException { - // Test ^, default and MULTILINE - // TODO - - // Test $, default and MULTILINE - // TODO - - // Test \b (word boundary) - // TODO - - // Test \B (not a word boundary) - // TODO - - // Test \A (beginning of string) - // TODO - - // Test \Z (end of string) - // TODO - - // Test \z (end of string) - // TODO - - // Test \G - // TODO - - // Test positive lookahead using (?=...) - // TODO - - // Test negative lookahead using (?!...) - // TODO - - // Test positive lookbehind using (?<=...) - // TODO - - // Test negative lookbehind using (?<!...) - // TODO - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method and matcher for created pattern.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testMisc() throws PatternSyntaxException { - Pattern p; - Matcher m; - - // Test (?>...) - // TODO - - // Test (?onflags-offflags) - // Valid flags are i,m,d,s,u,x - // TODO - - // Test (?onflags-offflags:...) - // TODO - - // Test \Q, \E - p = Pattern.compile("[a-z]+;\\Q[a-z]+;\\Q(foo.*);\\E[0-9]+"); - m = p.matcher("abc;[a-z]+;\\Q(foo.*);411"); - assertTrue(m.matches()); - m = p.matcher("abc;def;foo42;555"); - assertFalse(m.matches()); - m = p.matcher("abc;\\Qdef;\\Qfoo99;\\E123"); - assertFalse(m.matches()); - - p = Pattern.compile("[a-z]+;(foo[0-9]-\\Q(...)\\E);[0-9]+"); - m = p.matcher("abc;foo5-(...);123"); - assertTrue(m.matches()); - assertEquals("foo5-(...)", m.group(1)); - m = p.matcher("abc;foo9-(xxx);789"); - assertFalse(m.matches()); - - p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q$-\\E]+);[0-9]+"); - m = p.matcher("abc;bar0-def$-;123"); - assertTrue(m.matches()); - - // FIXME: - // This should work the same as the pattern above but fails with the - // the reference JDK - p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q-$\\E]+);[0-9]+"); - m = p.matcher("abc;bar0-def$-;123"); - // assertTrue(m.matches()); - - // FIXME: - // This should work too .. it looks as if just about anything that - // has more - // than one character between \Q and \E is broken in the the reference JDK - p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q[0-9]\\E]+);[0-9]+"); - m = p.matcher("abc;bar0-def[99]-]0x[;123"); - // assertTrue(m.matches()); - - // This is the same as above but with explicit escapes .. and this - // does work - // on the the reference JDK - p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\[0\\-9\\]]+);[0-9]+"); - m = p.matcher("abc;bar0-def[99]-]0x[;123"); - assertTrue(m.matches()); - - // Test #<comment text> - // TODO - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCompile1() throws PatternSyntaxException { - Pattern pattern = Pattern - .compile("[0-9A-Za-z][0-9A-Za-z\\x2e\\x3a\\x2d\\x5f]*"); - String name = "iso-8859-1"; - assertTrue(pattern.matcher(name).matches()); - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex, int flag) method.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - public void testCompile2() throws PatternSyntaxException { - String findString = "\\Qimport\\E"; - - Pattern pattern = Pattern.compile(findString, 0); - Matcher matcher = pattern.matcher(new String( - "import a.A;\n\n import b.B;\nclass C {}")); - - assertTrue(matcher.find(0)); - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) and compile(String regex, int flag) method for specific patterns.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) and compile(String regex, int flag) method for specific patterns.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testCompile3() throws PatternSyntaxException { - Pattern p; - Matcher m; - p = Pattern.compile("a$"); - m = p.matcher("a\n"); - assertTrue(m.find()); - assertEquals("a", m.group()); - assertFalse(m.find()); - - p = Pattern.compile("(a$)"); - m = p.matcher("a\n"); - assertTrue(m.find()); - assertEquals("a", m.group()); - assertEquals("a", m.group(1)); - assertFalse(m.find()); - - p = Pattern.compile("^.*$", Pattern.MULTILINE); - - m = p.matcher("a\n"); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("a", m.group()); - assertFalse(m.find()); - - m = p.matcher("a\nb\n"); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("a", m.group()); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("b", m.group()); - assertFalse(m.find()); - - m = p.matcher("a\nb"); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("a", m.group()); - assertTrue(m.find()); - assertEquals("b", m.group()); - assertFalse(m.find()); - - m = p.matcher("\naa\r\nbb\rcc\n\n"); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertTrue(m.group().equals("")); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("aa", m.group()); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("bb", m.group()); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertEquals("cc", m.group()); - assertTrue(m.find()); - // System.out.println("["+m.group()+"]"); - assertTrue(m.group().equals("")); - assertFalse(m.find()); - - m = p.matcher("a"); - assertTrue(m.find()); - assertEquals("a", m.group()); - assertFalse(m.find()); - -// BEGIN android-removed -// Makes no sense to duplicate this weird behavior -// m = p.matcher(""); -// // FIXME: This matches the reference behaviour but is -// // inconsistent with matching "a" - ie. the end of the -// // target string should match against $ always but this -// // appears to work with the null string only when not in -// // multiline mode (see below) -// assertFalse(m.find()); -// END android-removed - - p = Pattern.compile("^.*$"); - m = p.matcher(""); - assertTrue(m.find()); - assertTrue(m.group().equals("")); - assertFalse(m.find()); - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex, int flag) method for specific string.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - public void testCompile4() throws PatternSyntaxException { - String findString = "\\Qpublic\\E"; - StringBuffer text = new StringBuffer(" public class Class {\n" - + " public class Class {"); - - Pattern pattern = Pattern.compile(findString, 0); - Matcher matcher = pattern.matcher(text); - - boolean found = matcher.find(); - assertTrue(found); - assertEquals(4, matcher.start()); - if (found) { - // modify text - text.delete(0, text.length()); - text.append("Text have been changed."); - matcher.reset(text); - } - - found = matcher.find(); - assertFalse(found); - } - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) methodfor specific string.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCompile5() throws PatternSyntaxException { - Pattern p = Pattern.compile("^[0-9]"); - String s[] = p.split("12", -1); - assertEquals("", s[0]); - assertEquals("2", s[1]); - assertEquals(2, s.length); - } - - // public void testCompile6() { - // String regex = "[\\p{L}[\\p{Mn}[\\p{Pc}[\\p{Nd}[\\p{Nl}[\\p{Sc}]]]]]]+"; - // String regex = "[\\p{L}\\p{Mn}\\p{Pc}\\p{Nd}\\p{Nl}\\p{Sc}]+"; - // try { - // Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE); - // assertTrue(true); - // } catch (PatternSyntaxException e) { - // System.out.println(e.getMessage()); - // assertTrue(false); - // } - // } - - private static class UBInfo { - public UBInfo(int low, int high, String name) { - this.name = name; - this.low = low; - this.high = high; - } - - public String name; - - public int low, high; - } - - // A table representing the unicode categories - //private static UBInfo[] UCategories = { - // Lu - // Ll - // Lt - // Lm - // Lo - // Mn - // Mc - // Me - // Nd - // Nl - // No - // Pc - // Pd - // Ps - // Pe - // Pi - // Pf - // Po - // Sm - // Sc - // Sk - // So - // Zs - // Zl - // Zp - // Cc - // Cf - // Cs - // Co - // Cn - //}; - - // A table representing the unicode character blocks - private static UBInfo[] UBlocks = { - /* 0000; 007F; Basic Latin */ - new UBInfo(0x0000, 0x007F, "BasicLatin"), // Character.UnicodeBlock.BASIC_LATIN - /* 0080; 00FF; Latin-1 Supplement */ - new UBInfo(0x0080, 0x00FF, "Latin-1Supplement"), // Character.UnicodeBlock.LATIN_1_SUPPLEMENT - /* 0100; 017F; Latin Extended-A */ - new UBInfo(0x0100, 0x017F, "LatinExtended-A"), // Character.UnicodeBlock.LATIN_EXTENDED_A - /* 0180; 024F; Latin Extended-B */ - // new UBInfo (0x0180,0x024F,"InLatinExtended-B"), // - // Character.UnicodeBlock.LATIN_EXTENDED_B - /* 0250; 02AF; IPA Extensions */ - new UBInfo(0x0250, 0x02AF, "IPAExtensions"), // Character.UnicodeBlock.IPA_EXTENSIONS - /* 02B0; 02FF; Spacing Modifier Letters */ - new UBInfo(0x02B0, 0x02FF, "SpacingModifierLetters"), // Character.UnicodeBlock.SPACING_MODIFIER_LETTERS - /* 0300; 036F; Combining Diacritical Marks */ - new UBInfo(0x0300, 0x036F, "CombiningDiacriticalMarks"), // Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS - /* 0370; 03FF; Greek */ - new UBInfo(0x0370, 0x03FF, "Greek"), // Character.UnicodeBlock.GREEK - /* 0400; 04FF; Cyrillic */ - new UBInfo(0x0400, 0x04FF, "Cyrillic"), // Character.UnicodeBlock.CYRILLIC - /* 0530; 058F; Armenian */ - new UBInfo(0x0530, 0x058F, "Armenian"), // Character.UnicodeBlock.ARMENIAN - /* 0590; 05FF; Hebrew */ - new UBInfo(0x0590, 0x05FF, "Hebrew"), // Character.UnicodeBlock.HEBREW - /* 0600; 06FF; Arabic */ - new UBInfo(0x0600, 0x06FF, "Arabic"), // Character.UnicodeBlock.ARABIC - /* 0700; 074F; Syriac */ - new UBInfo(0x0700, 0x074F, "Syriac"), // Character.UnicodeBlock.SYRIAC - /* 0780; 07BF; Thaana */ - new UBInfo(0x0780, 0x07BF, "Thaana"), // Character.UnicodeBlock.THAANA - /* 0900; 097F; Devanagari */ - new UBInfo(0x0900, 0x097F, "Devanagari"), // Character.UnicodeBlock.DEVANAGARI - /* 0980; 09FF; Bengali */ - new UBInfo(0x0980, 0x09FF, "Bengali"), // Character.UnicodeBlock.BENGALI - /* 0A00; 0A7F; Gurmukhi */ - new UBInfo(0x0A00, 0x0A7F, "Gurmukhi"), // Character.UnicodeBlock.GURMUKHI - /* 0A80; 0AFF; Gujarati */ - new UBInfo(0x0A80, 0x0AFF, "Gujarati"), // Character.UnicodeBlock.GUJARATI - /* 0B00; 0B7F; Oriya */ - new UBInfo(0x0B00, 0x0B7F, "Oriya"), // Character.UnicodeBlock.ORIYA - /* 0B80; 0BFF; Tamil */ - new UBInfo(0x0B80, 0x0BFF, "Tamil"), // Character.UnicodeBlock.TAMIL - /* 0C00; 0C7F; Telugu */ - new UBInfo(0x0C00, 0x0C7F, "Telugu"), // Character.UnicodeBlock.TELUGU - /* 0C80; 0CFF; Kannada */ - new UBInfo(0x0C80, 0x0CFF, "Kannada"), // Character.UnicodeBlock.KANNADA - /* 0D00; 0D7F; Malayalam */ - new UBInfo(0x0D00, 0x0D7F, "Malayalam"), // Character.UnicodeBlock.MALAYALAM - /* 0D80; 0DFF; Sinhala */ - new UBInfo(0x0D80, 0x0DFF, "Sinhala"), // Character.UnicodeBlock.SINHALA - /* 0E00; 0E7F; Thai */ - new UBInfo(0x0E00, 0x0E7F, "Thai"), // Character.UnicodeBlock.THAI - /* 0E80; 0EFF; Lao */ - new UBInfo(0x0E80, 0x0EFF, "Lao"), // Character.UnicodeBlock.LAO - /* 0F00; 0FFF; Tibetan */ - new UBInfo(0x0F00, 0x0FFF, "Tibetan"), // Character.UnicodeBlock.TIBETAN - /* 1000; 109F; Myanmar */ - new UBInfo(0x1000, 0x109F, "Myanmar"), // Character.UnicodeBlock.MYANMAR - /* 10A0; 10FF; Georgian */ - new UBInfo(0x10A0, 0x10FF, "Georgian"), // Character.UnicodeBlock.GEORGIAN - /* 1100; 11FF; Hangul Jamo */ - new UBInfo(0x1100, 0x11FF, "HangulJamo"), // Character.UnicodeBlock.HANGUL_JAMO - /* 1200; 137F; Ethiopic */ - new UBInfo(0x1200, 0x137F, "Ethiopic"), // Character.UnicodeBlock.ETHIOPIC - /* 13A0; 13FF; Cherokee */ - new UBInfo(0x13A0, 0x13FF, "Cherokee"), // Character.UnicodeBlock.CHEROKEE - /* 1400; 167F; Unified Canadian Aboriginal Syllabics */ - new UBInfo(0x1400, 0x167F, "UnifiedCanadianAboriginalSyllabics"), // Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS - /* 1680; 169F; Ogham */ - new UBInfo(0x1680, 0x169F, "Ogham"), // Character.UnicodeBlock.OGHAM - /* 16A0; 16FF; Runic */ - new UBInfo(0x16A0, 0x16FF, "Runic"), // Character.UnicodeBlock.RUNIC - /* 1780; 17FF; Khmer */ - new UBInfo(0x1780, 0x17FF, "Khmer"), // Character.UnicodeBlock.KHMER - /* 1800; 18AF; Mongolian */ - new UBInfo(0x1800, 0x18AF, "Mongolian"), // Character.UnicodeBlock.MONGOLIAN - /* 1E00; 1EFF; Latin Extended Additional */ - new UBInfo(0x1E00, 0x1EFF, "LatinExtendedAdditional"), // Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL - /* 1F00; 1FFF; Greek Extended */ - new UBInfo(0x1F00, 0x1FFF, "GreekExtended"), // Character.UnicodeBlock.GREEK_EXTENDED - /* 2000; 206F; General Punctuation */ - new UBInfo(0x2000, 0x206F, "GeneralPunctuation"), // Character.UnicodeBlock.GENERAL_PUNCTUATION - /* 2070; 209F; Superscripts and Subscripts */ - new UBInfo(0x2070, 0x209F, "SuperscriptsandSubscripts"), // Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS - /* 20A0; 20CF; Currency Symbols */ - new UBInfo(0x20A0, 0x20CF, "CurrencySymbols"), // Character.UnicodeBlock.CURRENCY_SYMBOLS - /* 20D0; 20FF; Combining Marks for Symbols */ - new UBInfo(0x20D0, 0x20FF, "CombiningMarksforSymbols"), // Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS - /* 2100; 214F; Letterlike Symbols */ - new UBInfo(0x2100, 0x214F, "LetterlikeSymbols"), // Character.UnicodeBlock.LETTERLIKE_SYMBOLS - /* 2150; 218F; Number Forms */ - new UBInfo(0x2150, 0x218F, "NumberForms"), // Character.UnicodeBlock.NUMBER_FORMS - /* 2190; 21FF; Arrows */ - new UBInfo(0x2190, 0x21FF, "Arrows"), // Character.UnicodeBlock.ARROWS - /* 2200; 22FF; Mathematical Operators */ - new UBInfo(0x2200, 0x22FF, "MathematicalOperators"), // Character.UnicodeBlock.MATHEMATICAL_OPERATORS - /* 2300; 23FF; Miscellaneous Technical */ - new UBInfo(0x2300, 0x23FF, "MiscellaneousTechnical"), // Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL - /* 2400; 243F; Control Pictures */ - new UBInfo(0x2400, 0x243F, "ControlPictures"), // Character.UnicodeBlock.CONTROL_PICTURES - /* 2440; 245F; Optical Character Recognition */ - new UBInfo(0x2440, 0x245F, "OpticalCharacterRecognition"), // Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION - /* 2460; 24FF; Enclosed Alphanumerics */ - new UBInfo(0x2460, 0x24FF, "EnclosedAlphanumerics"), // Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS - /* 2500; 257F; Box Drawing */ - new UBInfo(0x2500, 0x257F, "BoxDrawing"), // Character.UnicodeBlock.BOX_DRAWING - /* 2580; 259F; Block Elements */ - new UBInfo(0x2580, 0x259F, "BlockElements"), // Character.UnicodeBlock.BLOCK_ELEMENTS - /* 25A0; 25FF; Geometric Shapes */ - new UBInfo(0x25A0, 0x25FF, "GeometricShapes"), // Character.UnicodeBlock.GEOMETRIC_SHAPES - /* 2600; 26FF; Miscellaneous Symbols */ - new UBInfo(0x2600, 0x26FF, "MiscellaneousSymbols"), // Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS - /* 2700; 27BF; Dingbats */ - new UBInfo(0x2700, 0x27BF, "Dingbats"), // Character.UnicodeBlock.DINGBATS - /* 2800; 28FF; Braille Patterns */ - new UBInfo(0x2800, 0x28FF, "BraillePatterns"), // Character.UnicodeBlock.BRAILLE_PATTERNS - /* 2E80; 2EFF; CJK Radicals Supplement */ - new UBInfo(0x2E80, 0x2EFF, "CJKRadicalsSupplement"), // Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT - /* 2F00; 2FDF; Kangxi Radicals */ - new UBInfo(0x2F00, 0x2FDF, "KangxiRadicals"), // Character.UnicodeBlock.KANGXI_RADICALS - /* 2FF0; 2FFF; Ideographic Description Characters */ - new UBInfo(0x2FF0, 0x2FFF, "IdeographicDescriptionCharacters"), // Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS - /* 3000; 303F; CJK Symbols and Punctuation */ - new UBInfo(0x3000, 0x303F, "CJKSymbolsandPunctuation"), // Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION - /* 3040; 309F; Hiragana */ - new UBInfo(0x3040, 0x309F, "Hiragana"), // Character.UnicodeBlock.HIRAGANA - /* 30A0; 30FF; Katakana */ - new UBInfo(0x30A0, 0x30FF, "Katakana"), // Character.UnicodeBlock.KATAKANA - /* 3100; 312F; Bopomofo */ - new UBInfo(0x3100, 0x312F, "Bopomofo"), // Character.UnicodeBlock.BOPOMOFO - /* 3130; 318F; Hangul Compatibility Jamo */ - new UBInfo(0x3130, 0x318F, "HangulCompatibilityJamo"), // Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO - /* 3190; 319F; Kanbun */ - new UBInfo(0x3190, 0x319F, "Kanbun"), // Character.UnicodeBlock.KANBUN - /* 31A0; 31BF; Bopomofo Extended */ - new UBInfo(0x31A0, 0x31BF, "BopomofoExtended"), // Character.UnicodeBlock.BOPOMOFO_EXTENDED - /* 3200; 32FF; Enclosed CJK Letters and Months */ - new UBInfo(0x3200, 0x32FF, "EnclosedCJKLettersandMonths"), // Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS - /* 3300; 33FF; CJK Compatibility */ - new UBInfo(0x3300, 0x33FF, "CJKCompatibility"), // Character.UnicodeBlock.CJK_COMPATIBILITY - /* 3400; 4DB5; CJK Unified Ideographs Extension A */ -// BEGIN android-changed -// Modified this to reflect current Unicode tables (or maybe it was a typo) - new UBInfo(0x3400, 0x4DBF, "CJKUnifiedIdeographsExtensionA"), // Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A -// END android-changed - /* 4E00; 9FFF; CJK Unified Ideographs */ - new UBInfo(0x4E00, 0x9FFF, "CJKUnifiedIdeographs"), // Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS - /* A000; A48F; Yi Syllables */ - new UBInfo(0xA000, 0xA48F, "YiSyllables"), // Character.UnicodeBlock.YI_SYLLABLES - /* A490; A4CF; Yi Radicals */ - new UBInfo(0xA490, 0xA4CF, "YiRadicals"), // Character.UnicodeBlock.YI_RADICALS - /* AC00; D7A3; Hangul Syllables */ -// BEGIN android-changed -// Modified this to reflect current Unicode tables (or maybe it was a typo) - new UBInfo(0xAC00, 0xD7AF, "HangulSyllables"), // Character.UnicodeBlock.HANGUL_SYLLABLES -// END android-changed - /* D800; DB7F; High Surrogates */ - /* DB80; DBFF; High Private Use Surrogates */ - /* DC00; DFFF; Low Surrogates */ - /* E000; F8FF; Private Use */ - /* F900; FAFF; CJK Compatibility Ideographs */ - new UBInfo(0xF900, 0xFAFF, "CJKCompatibilityIdeographs"), // Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS - /* FB00; FB4F; Alphabetic Presentation Forms */ - new UBInfo(0xFB00, 0xFB4F, "AlphabeticPresentationForms"), // Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS - /* FB50; FDFF; Arabic Presentation Forms-A */ - new UBInfo(0xFB50, 0xFDFF, "ArabicPresentationForms-A"), // Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A - /* FE20; FE2F; Combining Half Marks */ - new UBInfo(0xFE20, 0xFE2F, "CombiningHalfMarks"), // Character.UnicodeBlock.COMBINING_HALF_MARKS - /* FE30; FE4F; CJK Compatibility Forms */ - new UBInfo(0xFE30, 0xFE4F, "CJKCompatibilityForms"), // Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS - /* FE50; FE6F; Small Form Variants */ - new UBInfo(0xFE50, 0xFE6F, "SmallFormVariants"), // Character.UnicodeBlock.SMALL_FORM_VARIANTS - /* FE70; FEFE; Arabic Presentation Forms-B */ - // new UBInfo (0xFE70,0xFEFE,"InArabicPresentationForms-B"), // - // Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B - /* FEFF; FEFF; Specials */ -// BEGIN android-changed -// Modified this to reflect current Unicode tables (or maybe it was a typo) -// FEFF is actually still Arabic Presentation Forms B -// new UBInfo(0xFEFF, 0xFEFF, "Specials"), // Character.UnicodeBlock.SPECIALS -// END android-changed - /* FF00; FFEF; Halfwidth and Fullwidth Forms */ - new UBInfo(0xFF00, 0xFFEF, "HalfwidthandFullwidthForms"), // Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS - /* FFF0; FFFD; Specials */ - // BEGIN android-changed -// Modified this to reflect current Unicode tables (or maybe it was a typo) - new UBInfo(0xFFF0, 0xFFFF, "Specials") // Character.UnicodeBlock.SPECIALS -// END android-changed - }; -}
\ No newline at end of file diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternErrorTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternErrorTest.java deleted file mode 100644 index a9b782b..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternErrorTest.java +++ /dev/null @@ -1,103 +0,0 @@ -/* 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import java.util.regex.Pattern; -import junit.framework.TestCase; - -@TestTargetClass(Pattern.class) -/** - * Test boundary and error conditions in java.util.regex.Pattern - * - */ -public class PatternErrorTest extends TestCase { - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) and compile(String regex, int flag) method with invalid parameters. Doesn't verify IllegalArgumentException, PatternSyntaxException.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies compile(String regex) and compile(String regex, int flag) method with invalid parameters. Doesn't verify IllegalArgumentException, PatternSyntaxException.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testCompileErrors() throws Exception { - // null regex string - should get NullPointerException - try { - Pattern.compile(null); - fail("NullPointerException expected"); - } catch (NullPointerException e) { - } - - - // empty regex string - no exception should be thrown - Pattern.compile(""); - - // note: invalid regex syntax checked in PatternSyntaxExceptionTest - - // flags = 0 should raise no exception - int flags = 0; - Pattern.compile("foo", flags); - - // check that all valid flags accepted without exception - flags |= Pattern.UNIX_LINES; - flags |= Pattern.CASE_INSENSITIVE; - flags |= Pattern.MULTILINE; - // BEGIN android-changed - // We don't support that flag. - // flags |= Pattern.CANON_EQ; - // END android-changed - flags |= Pattern.COMMENTS; - flags |= Pattern.DOTALL; - flags |= Pattern.UNICODE_CASE; - Pattern.compile("foo", flags); - - // add invalid flags - should get IllegalArgumentException - /* - * TODO: Inconsistency between the reference JDK behaviour and spec - exception is - * not thrown - */ - /* - * Valid test is: - * flags |= 0xFFFFFFFF; - * try { - * Pattern.compile("foo",flags); - * } catch (IllegalArgumentException e) { - * // This is the expected exception - * } catch (Exception e) { - * fail(); - * } - */ - - /* Workaround test is: */ - // BEGIN android-changed - // We don't support that flag. - flags |= ~Pattern.CANON_EQ; - // END android-changed - // No exception expected to match incorrect the reference behaviour - Pattern.compile("foo", flags); - } -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.java deleted file mode 100644 index 9f3f389..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.java +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed 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.apache.harmony.regex.tests.java.util.regex; - -import java.util.regex.PatternSyntaxException; - -import junit.framework.TestCase; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; - -@TestTargetClass(PatternSyntaxException.class) -public class PatternSyntaxExceptionTest extends TestCase { - - @TestTargets({ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "PatternSyntaxException", - args = {java.lang.String.class, java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDescription", - args = {} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getPattern", - args = {} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getIndex", - args = {} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMessage", - args = {} - ) - }) - public void testPatternSyntaxException() { - // Normal case - PatternSyntaxException e = new PatternSyntaxException("Foo", "Bar", 0); - assertEquals("Foo", e.getDescription()); - assertEquals("Bar", e.getPattern()); - assertEquals(0, e.getIndex()); - - String s = e.getMessage(); - assertTrue(s.contains("Foo")); - assertTrue(s.contains("Bar")); - assertTrue(s.contains("0")); - - // No description specified - e = new PatternSyntaxException(null, "Bar", 0); - assertEquals(null, e.getDescription()); - assertEquals("Bar", e.getPattern()); - assertEquals(0, e.getIndex()); - - s = e.getMessage(); - assertFalse(s.contains("Foo")); - assertTrue(s.contains("Bar")); - assertTrue(s.contains("0")); - - // No pattern specified - e = new PatternSyntaxException("Foo", null, 0); - assertEquals("Foo", e.getDescription()); - assertEquals(null, e.getPattern()); - assertEquals(0, e.getIndex()); - - s = e.getMessage(); - assertTrue(s.contains("Foo")); - assertFalse(s.contains("Bar")); - assertTrue(s.contains("0")); - - // Neither description nor pattern specified - e = new PatternSyntaxException(null, null, 0); - assertEquals(null, e.getDescription()); - assertEquals(null, e.getPattern()); - assertEquals(0, e.getIndex()); - - s = e.getMessage(); - assertFalse(s.contains("Foo")); - assertFalse(s.contains("Bar")); - assertTrue(s.contains("0")); - - // No index specified - e = new PatternSyntaxException("Foo", "Bar", -1); - assertEquals(-1, e.getIndex()); - - s = e.getMessage(); - assertFalse(s.contains("^")); - - // No pattern, but index specified - e = new PatternSyntaxException("Foo", null, 0); - assertEquals(0, e.getIndex()); - - s = e.getMessage(); - assertFalse(s.contains("^")); - } - -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternTest.java deleted file mode 100644 index f70f9f1..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/PatternTest.java +++ /dev/null @@ -1,2410 +0,0 @@ -/* - * 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.BrokenTest; -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import java.io.Serializable; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.regex.PatternSyntaxException; - -import junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; -import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert; - -@TestTargetClass( - value = Pattern.class, - untestedMethods= { - @TestTargetNew( - level = TestLevel.NOT_FEASIBLE, - notes = "finalize is hard to test since the implementation only calls a native function", - method = "finalize", - args = {} - ) - } -) -public class PatternTest extends TestCase { - String[] testPatterns = { - "(a|b)*abb", - "(1*2*3*4*)*567", - "(a|b|c|d)*aab", - "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*", - "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*", - "(a|b)*(a|b)*A(a|b)*lice.*", - "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" - + "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do", -// BEGIN android-changed -// We don't have canonical equivalence. -// "x(?c)y", "x(?cc)y" -// "x(?:c)y" -// END android-changed - - }; - - String[] testPatternsAlt = { - /* - * According to JavaDoc 2 and 3 oct digit sequences like \\o70\\o347 - * should be OK, but test is failed for them - */ - "[ab]\\b\\\\o5\\xF9\\u1E7B\\t\\n\\f\\r\\a\\e[yz]", - "^\\p{Lower}*\\p{Upper}*\\p{ASCII}?\\p{Alpha}?\\p{Digit}*\\p{Alnum}\\p{Punct}\\p{Graph}\\p{Print}\\p{Blank}\\p{Cntrl}\\p{XDigit}\\p{Space}", - "$\\p{javaLowerCase}\\p{javaUpperCase}\\p{javaWhitespace}\\p{javaMirrored}", - "\\p{InGreek}\\p{Lu}\\p{Sc}\\P{InGreek}[\\p{L}&&[^\\p{Lu}]]" }; - - String[] wrongTestPatterns = { "\\o9A", "\\p{Lawer}", "\\xG0" }; - - final static int[] flagsSet = { Pattern.CASE_INSENSITIVE, - Pattern.MULTILINE, Pattern.DOTALL, Pattern.UNICODE_CASE - /* , Pattern.CANON_EQ */ }; - - /* - * Based on RI implenetation documents. Need to check this set regarding - * actual implementation. - */ - final static int[] wrongFlagsSet = { 256, 512, 1024 }; - - final static int DEFAULT_FLAGS = 0; - - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "TODO empty test", - method = "!", - args = {} - ) - @BrokenTest("empty test") - public void testMatcher() { - } - - /* - * Class under test for String[] split(CharSequence, int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of splitsplit(java.lang.String, int) method.", - method = "split", - args = {CharSequence.class, int.class} - ) - public void testSplitCharSequenceint() { - // splitting CharSequence which ends with pattern - // bug6193 - assertEquals(",,".split(",", 3).length, 3); - assertEquals(",,".split(",", 4).length, 3); - // bug6193 - // bug5391 - assertEquals(Pattern.compile("o").split("boo:and:foo", 5).length, 5); - assertEquals(Pattern.compile("b").split("ab", -1).length, 2); - // bug5391 - String s[]; - Pattern pat = Pattern.compile("x"); - s = pat.split("zxx:zzz:zxx", 10); - assertEquals(s.length, 5); - s = pat.split("zxx:zzz:zxx", 3); - assertEquals(s.length, 3); - s = pat.split("zxx:zzz:zxx", -1); - assertEquals(s.length, 5); - s = pat.split("zxx:zzz:zxx", 0); - assertEquals(s.length, 3); - // other splitting - // negative limit - pat = Pattern.compile("b"); - s = pat.split("abccbadfebb", -1); - assertEquals(s.length, 5); - s = pat.split("", -1); - assertEquals(s.length, 1); - pat = Pattern.compile(""); - s = pat.split("", -1); - assertEquals(s.length, 1); - s = pat.split("abccbadfe", -1); - assertEquals(s.length, 11); - // zero limit - pat = Pattern.compile("b"); - s = pat.split("abccbadfebb", 0); - assertEquals(s.length, 3); - s = pat.split("", 0); - assertEquals(s.length, 1); - pat = Pattern.compile(""); - s = pat.split("", 0); - assertEquals(s.length, 1); - s = pat.split("abccbadfe", 0); - assertEquals(s.length, 10); - // positive limit - pat = Pattern.compile("b"); - s = pat.split("abccbadfebb", 12); - assertEquals(s.length, 5); - s = pat.split("", 6); - assertEquals(s.length, 1); - pat = Pattern.compile(""); - s = pat.split("", 11); - assertEquals(s.length, 1); - s = pat.split("abccbadfe", 15); - assertEquals(s.length, 11); - - pat = Pattern.compile("b"); - s = pat.split("abccbadfebb", 5); - assertEquals(s.length, 5); - s = pat.split("", 1); - assertEquals(s.length, 1); - pat = Pattern.compile(""); - s = pat.split("", 1); - assertEquals(s.length, 1); - s = pat.split("abccbadfe", 11); - assertEquals(s.length, 11); - - pat = Pattern.compile("b"); - s = pat.split("abccbadfebb", 3); - assertEquals(s.length, 3); - pat = Pattern.compile(""); - s = pat.split("abccbadfe", 5); - assertEquals(s.length, 5); - } - - /* - * Class under test for String[] split(CharSequence) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of splitsplit(java.lang.String) method.", - method = "split", - args = {CharSequence.class} - ) - public void testSplitCharSequence() { - String s[]; - Pattern pat = Pattern.compile("b"); - s = pat.split("abccbadfebb"); - assertEquals(s.length, 3); - s = pat.split(""); - assertEquals(s.length, 1); - pat = Pattern.compile(""); - s = pat.split(""); - assertEquals(s.length, 1); - s = pat.split("abccbadfe"); - assertEquals(s.length, 10); - // bug6544 - String s1 = ""; - String[] arr = s1.split(":"); - assertEquals(arr.length, 1); - // bug6544 - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "Verifies the functionality of pattern() method.", - method = "pattern", - args = {} - ) - public void testPattern() { - /* Positive assertion test. */ - for (String aPattern : testPatterns) { - Pattern p = Pattern.compile(aPattern); - try { - assertTrue(p.pattern().equals(aPattern)); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCompile() { - /* Positive assertion test. */ - for (String aPattern : testPatterns) { - try { - Pattern p = Pattern.compile(aPattern); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - - /* Positive assertion test with alternative templates. */ - for (String aPattern : testPatternsAlt) { - try { - Pattern p = Pattern.compile(aPattern); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - - /* Negative assertion test. */ - for (String aPattern : wrongTestPatterns) { - try { - Pattern p = Pattern.compile(aPattern); - fail("PatternSyntaxException is expected"); - } catch (PatternSyntaxException pse) { - /* OKAY */ - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method for different flags.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFlags() { - String baseString; - String testString; - Pattern pat; - Matcher mat; - - baseString = "((?i)|b)a"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - baseString = "(?i)a|b"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)a|b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "c|(?i)a|b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)a|(?s)b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)a|(?-i)b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - baseString = "(?i)a|(?-i)c|b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - baseString = "(?i)a|(?-i)c|(?i)b"; - testString = "B"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)a|(?-i)b"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "((?i))a"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - baseString = "|(?i)|a"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)((?s)a.)"; - testString = "A\n"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)((?-i)a)"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - baseString = "(?i)(?s:a.)"; - testString = "A\n"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)fgh(?s:aa)"; - testString = "fghAA"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?i)((?-i))a"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "abc(?i)d"; - testString = "ABCD"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - testString = "abcD"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "a(?i)a(?-i)a(?i)a(?-i)a"; - testString = "aAaAa"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "aAAAa"; - mat = pat.matcher(testString); - assertFalse(mat.matches()); - } - -// BEGIN android-removed -// The flags() method should only return those flags that were explicitly -// passed during the compilation. The JDK also accepts the ones implicitly -// contained in the pattern, but ICU doesn't do this. -// -// public void testFlagsMethod() { -// String baseString; -// Pattern pat; -// -// /* -// * These tests are for compatibility with RI only. Logically we have to -// * return only flags specified during the compilation. For example -// * pat.flags() == 0 when we compile Pattern pat = -// * Pattern.compile("(?i)abc(?-i)"); but the whole expression is compiled -// * in a case insensitive manner. So there is little sense to do calls to -// * flags() now. -// */ -// baseString = "(?-i)"; -// pat = Pattern.compile(baseString); -// -// baseString = "(?idmsux)abc(?-i)vg(?-dmu)"; -// pat = Pattern.compile(baseString); -// assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS); -// -// baseString = "(?idmsux)abc|(?-i)vg|(?-dmu)"; -// pat = Pattern.compile(baseString); -// assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS); -// -// baseString = "(?is)a((?x)b.)"; -// pat = Pattern.compile(baseString); -// assertEquals(pat.flags(), Pattern.DOTALL | Pattern.CASE_INSENSITIVE); -// -// baseString = "(?i)a((?-i))"; -// pat = Pattern.compile(baseString); -// assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE); -// -// baseString = "((?i)a)"; -// pat = Pattern.compile(baseString); -// assertEquals(pat.flags(), 0); -// -// pat = Pattern.compile("(?is)abc"); -// assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE | Pattern.DOTALL); -// } -//END android-removed - - /* - * Check default flags when they are not specified in pattern. Based on RI - * since could not find that info - */ - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of flags() method for default flags.", - method = "flags", - args = {} - ) - public void testFlagsCompileDefault() { - for (String pat : testPatternsAlt) { - try { - Pattern p = Pattern.compile(pat); - assertEquals(p.flags(), DEFAULT_FLAGS); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - - /* - * Check that flags specified during compile are set properly This is a - * simple implementation that does not use flags combinations. Need to - * improve. - */ - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & flags() methods. Checks that compilation was corect.", - method = "flags", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & flags() methods. Checks that compilation was corect.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testFlagsCompileValid() { - for (String pat : testPatternsAlt) { - for (int flags : flagsSet) { - try { - Pattern p = Pattern.compile(pat, flags); - assertEquals(p.flags(), flags); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - } - - /* - * Class under test for Pattern compile(String, int) - */ - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.Checks that correct exceptions were thrown.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCompileStringint() { - /* - * these tests are needed to verify that appropriate exceptions are - * thrown - */ - String pattern = "b)a"; - try { - Pattern.compile(pattern); - fail("Expected a PatternSyntaxException when compiling pattern: " - + pattern); - } catch (PatternSyntaxException e) { - // pass - } - pattern = "bcde)a"; - try { - Pattern.compile(pattern); - fail("Expected a PatternSyntaxException when compiling pattern: " - + pattern); - } catch (PatternSyntaxException e) { - // pass - } - pattern = "bbg())a"; - try { - Pattern pat = Pattern.compile(pattern); - fail("Expected a PatternSyntaxException when compiling pattern: " - + pattern); - } catch (PatternSyntaxException e) { - // pass - } - - pattern = "cdb(?i))a"; - try { - Pattern pat = Pattern.compile(pattern); - fail("Expected a PatternSyntaxException when compiling pattern: " - + pattern); - } catch (PatternSyntaxException e) { - // pass - } - - /* - * This pattern should compile - HARMONY-2127 - */ -// pattern = "x(?c)y"; -// Pattern.compile(pattern); - - /* - * this pattern doesn't match any string, but should be compiled anyway - */ - pattern = "(b\\1)a"; - Pattern.compile(pattern); - } - - /* - * Class under test for Pattern compile(String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.Checks that correct exceptions were thrown.", - method = "compile", - args = {java.lang.String.class} - ) - public void testQuantCompileNeg() { - String[] patterns = { "5{,2}", "{5asd", "{hgdhg", "{5,hjkh", "{,5hdsh", - "{5,3shdfkjh}" }; - for (String element : patterns) { - try { - Pattern.compile(element); - fail("PatternSyntaxException was expected, but compilation succeeds"); - } catch (PatternSyntaxException pse) { - continue; - } - } - // Regression for HARMONY-1365 -// BEGIN android-changed -// Original regex contained some illegal stuff. Changed it slightly, -// while maintaining the wicked character of this "mother of all -// regexes". -// String pattern = "(?![^\\<C\\f\\0146\\0270\\}&&[|\\02-\\x3E\\}|X-\\|]]{7,}+)[|\\\\\\x98\\<\\?\\u4FCFr\\,\\0025\\}\\004|\\0025-\\052\061]|(?<![|\\01-\\u829E])|(?<!\\p{Alpha})|^|(?-s:[^\\x15\\\\\\x24F\\a\\,\\a\\u97D8[\\x38\\a[\\0224-\\0306[^\\0020-\\u6A57]]]]??)(?uxix:[^|\\{\\[\\0367\\t\\e\\x8C\\{\\[\\074c\\]V[|b\\fu\\r\\0175\\<\\07f\\066s[^D-\\x5D]]])(?xx:^{5,}+)(?uuu)(?=^\\D)|(?!\\G)(?>\\G*?)(?![^|\\]\\070\\ne\\{\\t\\[\\053\\?\\\\\\x51\\a\\075\\0023-\\[&&[|\\022-\\xEA\\00-\\u41C2&&[^|a-\\xCC&&[^\\037\\uECB3\\u3D9A\\x31\\|\\<b\\0206\\uF2EC\\01m\\,\\ak\\a\\03&&\\p{Punct}]]]])(?-dxs:[|\\06-\\07|\\e-\\x63&&[|Tp\\u18A3\\00\\|\\xE4\\05\\061\\015\\0116C|\\r\\{\\}\\006\\xEA\\0367\\xC4\\01\\0042\\0267\\xBB\\01T\\}\\0100\\?[|\\[-\\u459B|\\x23\\x91\\rF\\0376[|\\?-\\x94\\0113-\\\\\\s]]]]{6}?)(?<=[^\\t-\\x42H\\04\\f\\03\\0172\\?i\\u97B6\\e\\f\\uDAC2])(?=\\B*+)(?>[^\\016\\r\\{\\,\\uA29D\\034\\02[\\02-\\[|\\t\\056\\uF599\\x62\\e\\<\\032\\uF0AC\\0026\\0205Q\\|\\\\\\06\\0164[|\\057-\\u7A98&&[\\061-g|\\|\\0276\\n\\042\\011\\e\\xE8\\x64B\\04\\u6D0EDW^\\p{Lower}]]]]?)(?<=[^\\n\\\\\\t\\u8E13\\,\\0114\\u656E\\xA5\\]&&[\\03-\\026|\\uF39D\\01\\{i\\u3BC2\\u14FE]])(?<=[^|\\uAE62\\054H\\|\\}&&^\\p{Space}])(?sxx)(?<=[\\f\\006\\a\\r\\xB4]*+)|(?x-xd:^{5}+)()"; - String pattern = "(?![^\\<C\\f\\0146\\0270\\}&&[|\\02-\\x3E\\}|X-\\|]]{7,}+)[|\\\\\\x98\\<\\?\\u4FCFr\\,\\0025\\}\\004|\\0025-\\052\061]|(?<![|\\01-\\u829E])|(?<!\\p{Alpha})|^|(?-s:[^\\x15\\\\\\x24F\\a\\,\\a\\u97D8[\\x38\\a[\\0224-\\0306[^\\0020-\\u6A57]]]]??)(?uxix:[^|\\{\\[\\0367\\t\\e\\x8C\\{\\[\\074c\\]V[|b\\fu\\r\\0175\\<\\07f\\066s[^D-\\x5D]]])(?xx:^{5,}+)(?uuu)(?=^\\D)|(?!\\G)(?>\\.*?)(?![^|\\]\\070\\ne\\{\\t\\[\\053\\?\\\\\\x51\\a\\075\\0023-\\[&&[|\\022-\\xEA\\00-\\u41C2&&[^|a-\\xCC&&[^\\037\\uECB3\\u3D9A\\x31\\|\\<b\\0206\\uF2EC\\01m\\,\\ak\\a\\03&&\\p{Punct}]]]])(?-dxs:[|\\06-\\07|\\e-\\x63&&[|Tp\\u18A3\\00\\|\\xE4\\05\\061\\015\\0116C|\\r\\{\\}\\006\\xEA\\0367\\xC4\\01\\0042\\0267\\xBB\\01T\\}\\0100\\?[|\\[-\\u459B|\\x23\\x91\\rF\\0376[|\\?-\\x94\\0113-\\\\\\s]]]]{6}?)(?<=[^\\t-\\x42H\\04\\f\\03\\0172\\?i\\u97B6\\e\\f\\uDAC2])(?=\\.*+)(?>[^\\016\\r\\{\\,\\uA29D\\034\\02[\\02-\\[|\\t\\056\\uF599\\x62\\e\\<\\032\\uF0AC\\0026\\0205Q\\|\\\\\\06\\0164[|\\057-\\u7A98&&[\\061-g|\\|\\0276\\n\\042\\011\\e\\xE8\\x64B\\04\\u6D0EDW^\\p{Lower}]]]]?)(?<=[^\\n\\\\\\t\\u8E13\\,\\0114\\u656E\\xA5\\]&&[\\03-\\026|\\uF39D\\01\\{i\\u3BC2\\u14FE]])(?<=[^|\\uAE62\\054H\\|\\}&&^\\p{Space}])(?sxx)(?<=[\\f\\006\\a\\r\\xB4]{1,5})|(?x-xd:^{5}+)()"; -// END android-changed - assertNotNull(Pattern.compile(pattern)); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testQuantCompilePos() { - String[] patterns = {/* "(abc){1,3}", */"abc{2,}", "abc{5}" }; - for (String element : patterns) { - Pattern.compile(element); - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile() method. Also tested methods from matcher: matches(), start(int), group(int)", - method = "compile", - args = {java.lang.String.class} - ) - public void testQuantComposition() { - String pattern = "(a{1,3})aab"; - java.util.regex.Pattern pat = java.util.regex.Pattern.compile(pattern); - java.util.regex.Matcher mat = pat.matcher("aaab"); - mat.matches(); - mat.start(1); - mat.group(1); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testMatches() { - String[][] posSeq = { - { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" }, - { "213567", "12324567", "1234567", "213213567", - "21312312312567", "444444567" }, - { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" }, - { "213234567", "3458", "0987654", "7689546432", "0398576", - "98432", "5" }, - { - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" }, - { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", - "abbbAbbbliceaaa", "Alice" }, - { "a123", "bnxnvgds156", "for", "while", "if", "struct" }, - { "xy" }, { "xy" }, { "xcy" } - - }; - - for (int i = 0; i < testPatterns.length; i++) { - for (int j = 0; j < posSeq[i].length; j++) { - assertTrue("Incorrect match: " + testPatterns[i] + " vs " - + posSeq[i][j], Pattern.matches(testPatterns[i], - posSeq[i][j])); - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies exception", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testMatchesException() { - /* Negative assertion test. */ - for (String aPattern : wrongTestPatterns) { - try { - Pattern.matches(aPattern, "Foo"); - fail("PatternSyntaxException is expected"); - } catch (PatternSyntaxException pse) { - /* OKAY */ - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of matches(java.lang.String,java.lang.CharSequence) method.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testTimeZoneIssue() { - Pattern p = Pattern.compile("GMT(\\+|\\-)(\\d+)(:(\\d+))?"); - Matcher m = p.matcher("GMT-9:45"); - assertTrue(m.matches()); - assertEquals("-", m.group(1)); - assertEquals("9", m.group(2)); - assertEquals(":45", m.group(3)); - assertEquals("45", m.group(4)); - } - -// BEGIN android-changed -// Removed one pattern that is buggy on the JDK. We don't want to duplicate that. - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of matches(java.lang.String,java.lang.CharSequence) method.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testCompileRanges() { - String[] correctTestPatterns = { "[^]*abb]*", /* "[^a-d[^m-p]]*abb", */ - "[a-d\\d]*abb", "[abc]*abb", "[a-e&&[de]]*abb", "[^abc]*abb", - "[a-e&&[^de]]*abb", "[a-z&&[^m-p]]*abb", "[a-d[m-p]]*abb", - "[a-zA-Z]*abb", "[+*?]*abb", "[^+*?]*abb" }; - - String[] inputSecuence = { "kkkk", /* "admpabb", */ "abcabcd124654abb", - "abcabccbacababb", "dededededededeedabb", "gfdhfghgdfghabb", - "accabacbcbaabb", "acbvfgtyabb", "adbcacdbmopabcoabb", - "jhfkjhaSDFGHJkdfhHNJMjkhfabb", "+*??+*abb", "sdfghjkabb" }; - - Pattern pat; - - for (int i = 0; i < correctTestPatterns.length; i++) { - assertTrue("pattern: " + correctTestPatterns[i] + " input: " - + inputSecuence[i], Pattern.matches(correctTestPatterns[i], - inputSecuence[i])); - - } - - String[] wrongInputSecuence = { "]", /* "admpkk", */ "abcabcd124k654abb", - "abwcabccbacababb", "abababdeababdeabb", "abcabcacbacbabb", - "acdcbecbaabb", "acbotyabb", "adbcaecdbmopabcoabb", - "jhfkjhaSDFGHJk;dfhHNJMjkhfabb", "+*?a?+*abb", "sdf+ghjkabb" }; - - for (int i = 0; i < correctTestPatterns.length; i++) { - assertFalse("pattern: " + correctTestPatterns[i] + " input: " - + wrongInputSecuence[i], Pattern.matches( - correctTestPatterns[i], wrongInputSecuence[i])); - - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of matches(java.lang.String,java.lang.CharSequence) method for ranged patterns.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testRangesSpecialCases() { - String neg_patterns[] = { "[a-&&[b-c]]", "[a-\\w]", "[b-a]", "[]" }; - - for (String element : neg_patterns) { - try { - Pattern.compile(element); - fail("PatternSyntaxException was expected: " + element); - } catch (PatternSyntaxException pse) { - } - } - - String pos_patterns[] = { "[-]+", "----", "[a-]+", "a-a-a-a-aa--", - "[\\w-a]+", "123-2312--aaa-213", "[a-]]+", "-]]]]]]]]]]]]]]]" }; - - for (int i = 0; i < pos_patterns.length; i++) { - String pat = pos_patterns[i++]; - String inp = pos_patterns[i]; - assertTrue("pattern: " + pat + " input: " + inp, Pattern.matches( - pat, inp)); - } - } - // END android-changed - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of matches(java.lang.String,java.lang.CharSequence) method.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) -public void testZeroSymbols() { - assertTrue(Pattern.matches("[\0]*abb", "\0\0\0\0\0\0abb")); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of matcher(java.lang.String) method.", - method = "matcher", - args = {CharSequence.class} - ) - public void testEscapes() { - Pattern pat = Pattern.compile("\\Q{]()*?"); - Matcher mat = pat.matcher("{]()*?"); - - assertTrue(mat.matches()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testBug181() { - Pattern.compile("[\\t-\\r]"); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testOrphanQuantifiers() { - try { - Pattern.compile("+++++"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException pse) { - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testOrphanQuantifiers2() { - try { - Pattern pat = Pattern.compile("\\d+*"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException pse) { - } - } - - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - }) - public void testBug197() { - Object[] vals = { ":", new Integer(2), - new String[] { "boo", "and:foo" }, ":", new Integer(5), - new String[] { "boo", "and", "foo" }, ":", new Integer(-2), - new String[] { "boo", "and", "foo" }, ":", new Integer(3), - new String[] { "boo", "and", "foo" }, ":", new Integer(1), - new String[] { "boo:and:foo" }, "o", new Integer(5), - new String[] { "b", "", ":and:f", "", "" }, "o", - new Integer(4), new String[] { "b", "", ":and:f", "o" }, "o", - new Integer(-2), new String[] { "b", "", ":and:f", "", "" }, - "o", new Integer(0), new String[] { "b", "", ":and:f" } }; - - for (int i = 0; i < vals.length / 3;) { - String[] res = Pattern.compile(vals[i++].toString()).split( - "boo:and:foo", ((Integer) vals[i++]).intValue()); - String[] expectedRes = (String[]) vals[i++]; - - assertEquals(expectedRes.length, res.length); - - for (int j = 0; j < expectedRes.length; j++) { - assertEquals(expectedRes[j], res[j]); - } - } - } - - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testURIPatterns() { - String URI_REGEXP_STR = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?"; - String SCHEME_REGEXP_STR = "^[a-zA-Z]{1}[\\w+-.]+$"; - String REL_URI_REGEXP_STR = "^(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?"; - String IPV6_REGEXP_STR = "^[0-9a-fA-F\\:\\.]+(\\%\\w+)?$"; - String IPV6_REGEXP_STR2 = "^\\[[0-9a-fA-F\\:\\.]+(\\%\\w+)?\\]$"; - String IPV4_REGEXP_STR = "^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$"; - String HOSTNAME_REGEXP_STR = "\\w+[\\w\\-\\.]*"; - - Pattern URI_REGEXP = Pattern.compile(URI_REGEXP_STR); - Pattern REL_URI_REGEXP = Pattern.compile(REL_URI_REGEXP_STR); - Pattern SCHEME_REGEXP = Pattern.compile(SCHEME_REGEXP_STR); - Pattern IPV4_REGEXP = Pattern.compile(IPV4_REGEXP_STR); - Pattern IPV6_REGEXP = Pattern.compile(IPV6_REGEXP_STR); - Pattern IPV6_REGEXP2 = Pattern.compile(IPV6_REGEXP_STR2); - Pattern HOSTNAME_REGEXP = Pattern.compile(HOSTNAME_REGEXP_STR); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases1() { - Pattern pat = Pattern.compile(".*\n"); - Matcher mat = pat.matcher("a\n"); - - mat.find(); - assertEquals("a\n", mat.group()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases2() { - Pattern pat = Pattern.compile(".*A"); - Matcher mat = pat.matcher("aAa"); - - mat.find(); - assertEquals("aA", mat.group()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases3() { - Pattern pat = Pattern.compile(".*A"); - Matcher mat = pat.matcher("a\naA\n"); - - mat.find(); - assertEquals("aA", mat.group()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases4() { - Pattern pat = Pattern.compile("A.*"); - Matcher mat = pat.matcher("A\n"); - - mat.find(); - assertEquals("A", mat.group()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases5() { - Pattern pat = Pattern.compile(".*A.*"); - Matcher mat = pat.matcher("\nA\naaa\nA\naaAaa\naaaA\n"); - // Matcher mat = pat.matcher("\nA\n"); - String[] res = { "A", "A", "aaAaa", "aaaA" }; - int k = 0; - for (; mat.find(); k++) { - assertEquals(res[k], mat.group()); - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testFindBoundaryCases6() { - String[] res = { "", "a", "", "" }; - Pattern pat = Pattern.compile(".*"); - Matcher mat = pat.matcher("\na\n"); - int k = 0; - - for (; mat.find(); k++) { - assertEquals(res[k], mat.group()); - } - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testBackReferences() { - Pattern pat = Pattern.compile("(\\((\\w*):(.*):(\\2)\\))"); - Matcher mat = pat - .matcher("(start1: word :start1)(start2: word :start2)"); - int k = 1; - for (; mat.find(); k++) { - assertEquals("start" + k, mat.group(2)); - assertEquals(" word ", mat.group(3)); - assertEquals("start" + k, mat.group(4)); - } - - assertEquals(3, k); - pat = Pattern.compile(".*(.)\\1"); - mat = pat.matcher("saa"); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testNewLine() { - Pattern pat = Pattern.compile("(^$)*\n", Pattern.MULTILINE); - Matcher mat = pat.matcher("\r\n\n"); - int counter = 0; - while (mat.find()) { - counter++; - } - assertEquals(2, counter); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testFindGreedy() { - Pattern pat = Pattern.compile(".*aaa", Pattern.DOTALL); - Matcher mat = pat.matcher("aaaa\naaa\naaaaaa"); - mat.matches(); - assertEquals(15, mat.end()); - } - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies serialization/deserialization.", - method = "!SerializationSelf", - args = {} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies serialization/deserialization.", - method = "!SerializationGolden", - args = {} - ) - }) - public void testSerialization() throws Exception { - Pattern pat = Pattern.compile("a*bc"); - SerializableAssert comparator = new SerializableAssert() { - public void assertDeserialized(Serializable initial, - Serializable deserialized) { - assertEquals(((Pattern) initial).toString(), - ((Pattern) deserialized).toString()); - } - }; - SerializationTest.verifyGolden(this, pat, comparator); - SerializationTest.verifySelf(pat, comparator); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testSOLQuant() { - Pattern pat = Pattern.compile("$*", Pattern.MULTILINE); - Matcher mat = pat.matcher("\n\n"); - int counter = 0; - while (mat.find()) { - counter++; - } - - assertEquals(3, counter); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testIllegalEscape() { - try { - Pattern.compile("\\y"); - fail("PatternSyntaxException expected"); - } catch (PatternSyntaxException pse) { - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testEmptyFamily() { - Pattern.compile("\\p{Lower}"); - String a = "*"; - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testNonCaptConstr() { - // Flags - Pattern pat = Pattern.compile("(?i)b*(?-i)a*"); - assertTrue(pat.matcher("bBbBaaaa").matches()); - assertFalse(pat.matcher("bBbBAaAa").matches()); - - // Non-capturing groups - pat = Pattern.compile("(?i:b*)a*"); - assertTrue(pat.matcher("bBbBaaaa").matches()); - assertFalse(pat.matcher("bBbBAaAa").matches()); - - pat = Pattern - // 1 2 3 4 5 6 7 8 9 10 11 - .compile("(?:-|(-?\\d+\\d\\d\\d))?(?:-|-(\\d\\d))?(?:-|-(\\d\\d))?(T)?(?:(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?)?(?:(?:((?:\\+|\\-)\\d\\d):(\\d\\d))|(Z))?"); - Matcher mat = pat.matcher("-1234-21-31T41:51:61.789+71:81"); - assertTrue(mat.matches()); - assertEquals("-1234", mat.group(1)); - assertEquals("21", mat.group(2)); - assertEquals("31", mat.group(3)); - assertEquals("T", mat.group(4)); - assertEquals("41", mat.group(5)); - assertEquals("51", mat.group(6)); - assertEquals("61", mat.group(7)); - assertEquals(".789", mat.group(8)); - assertEquals("+71", mat.group(9)); - assertEquals("81", mat.group(10)); - - // positive lookahead - pat = Pattern.compile(".*\\.(?=log$).*$"); - assertTrue(pat.matcher("a.b.c.log").matches()); - assertFalse(pat.matcher("a.b.c.log.").matches()); - - // negative lookahead - pat = Pattern.compile(".*\\.(?!log$).*$"); - assertFalse(pat.matcher("abc.log").matches()); - assertTrue(pat.matcher("abc.logg").matches()); - - // positive lookbehind - pat = Pattern.compile(".*(?<=abc)\\.log$"); - assertFalse(pat.matcher("cde.log").matches()); - assertTrue(pat.matcher("abc.log").matches()); - - // negative lookbehind - pat = Pattern.compile(".*(?<!abc)\\.log$"); - assertTrue(pat.matcher("cde.log").matches()); - assertFalse(pat.matcher("abc.log").matches()); - - // atomic group - pat = Pattern.compile("(?>a*)abb"); - assertFalse(pat.matcher("aaabb").matches()); - pat = Pattern.compile("(?>a*)bb"); - assertTrue(pat.matcher("aaabb").matches()); - - pat = Pattern.compile("(?>a|aa)aabb"); - assertTrue(pat.matcher("aaabb").matches()); - pat = Pattern.compile("(?>aa|a)aabb"); - assertFalse(pat.matcher("aaabb").matches()); - -// BEGIN android-removed -// Questionable constructs that ICU doesn't support. -// // quantifiers over look ahead -// pat = Pattern.compile(".*(?<=abc)*\\.log$"); -// assertTrue(pat.matcher("cde.log").matches()); -// pat = Pattern.compile(".*(?<=abc)+\\.log$"); -// assertFalse(pat.matcher("cde.log").matches()); -// END android-removed - - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCorrectReplacementBackreferencedJointSet() { - Pattern pat = Pattern.compile("ab(a)*\\1"); - pat = Pattern.compile("abc(cd)fg"); - pat = Pattern.compile("aba*cd"); - pat = Pattern.compile("ab(a)*+cd"); - pat = Pattern.compile("ab(a)*?cd"); - pat = Pattern.compile("ab(a)+cd"); - pat = Pattern.compile(".*(.)\\1"); - pat = Pattern.compile("ab((a)|c|d)e"); - pat = Pattern.compile("abc((a(b))cd)"); - pat = Pattern.compile("ab(a)++cd"); - pat = Pattern.compile("ab(a)?(c)d"); - pat = Pattern.compile("ab(a)?+cd"); - pat = Pattern.compile("ab(a)??cd"); - pat = Pattern.compile("ab(a)??cd"); - pat = Pattern.compile("ab(a){1,3}?(c)d"); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testCompilePatternWithTerminatorMark() { - Pattern pat = Pattern.compile("a\u0000\u0000cd"); - Matcher mat = pat.matcher("a\u0000\u0000cd"); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testAlternations() { - String baseString = "|a|bc"; - Pattern pat = Pattern.compile(baseString); - Matcher mat = pat.matcher(""); - - assertTrue(mat.matches()); - - baseString = "a||bc"; - pat = Pattern.compile(baseString); - mat = pat.matcher(""); - assertTrue(mat.matches()); - - baseString = "a|bc|"; - pat = Pattern.compile(baseString); - mat = pat.matcher(""); - assertTrue(mat.matches()); - - baseString = "a|b|"; - pat = Pattern.compile(baseString); - mat = pat.matcher(""); - assertTrue(mat.matches()); - - baseString = "a(|b|cd)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "a(b||cd)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "a(b|cd|)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "a(b|c|)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "a(|)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "|"; - pat = Pattern.compile(baseString); - mat = pat.matcher(""); - assertTrue(mat.matches()); - - baseString = "a(?:|)e"; - pat = Pattern.compile(baseString); - mat = pat.matcher("ae"); - assertTrue(mat.matches()); - - baseString = "a||||bc"; - pat = Pattern.compile(baseString); - mat = pat.matcher(""); - assertTrue(mat.matches()); - - baseString = "(?i-is)|a"; - pat = Pattern.compile(baseString); - mat = pat.matcher("a"); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testMatchWithGroups() { - String baseString = "jwkerhjwehrkwjehrkwjhrwkjehrjwkehrjkwhrkwehrkwhrkwrhwkhrwkjehr"; - String pattern = ".*(..).*\\1.*"; - assertTrue(Pattern.compile(pattern).matcher(baseString).matches()); - - baseString = "saa"; - pattern = ".*(.)\\1"; - assertTrue(Pattern.compile(pattern).matcher(baseString).matches()); - assertTrue(Pattern.compile(pattern).matcher(baseString).find()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies split method for empty string.", - method = "split", - args = {java.lang.CharSequence.class} - ) - public void testSplitEmptyCharSequence() { - String s1 = ""; - String[] arr = s1.split(":"); - assertEquals(arr.length, 1); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of compile(java.lang.String) & split(java.lang.CharSequence, int) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of compile(java.lang.String) & split(java.lang.CharSequence, int) methods.", - method = "split", - args = {java.lang.CharSequence.class, int.class} - ) - }) - public void testSplitEndsWithPattern() { - assertEquals(",,".split(",", 3).length, 3); - assertEquals(",,".split(",", 4).length, 3); - - assertEquals(Pattern.compile("o").split("boo:and:foo", 5).length, 5); - assertEquals(Pattern.compile("b").split("ab", -1).length, 2); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of matches(java.lang.String), java.lang.CharSequence) method for case insensitive flags.", - method = "matches", - args = {java.lang.String.class, java.lang.CharSequence.class} - ) - public void testCaseInsensitiveFlag() { - assertTrue(Pattern.matches("(?i-:AbC)", "ABC")); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testEmptyGroups() { - Pattern pat = Pattern.compile("ab(?>)cda"); - Matcher mat = pat.matcher("abcda"); - assertTrue(mat.matches()); - - pat = Pattern.compile("ab()"); - mat = pat.matcher("ab"); - assertTrue(mat.matches()); - - pat = Pattern.compile("abc(?:)(..)"); - mat = pat.matcher("abcgf"); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ) - }) - public void testCompileNonCaptGroup() { - boolean isCompiled = false; - - try { -// BEGIN android-change -// We don't have canonical equivalence. - Pattern pat = Pattern.compile("(?:)"); - pat = Pattern.compile("(?:)", Pattern.DOTALL); - pat = Pattern.compile("(?:)", Pattern.CASE_INSENSITIVE); - pat = Pattern.compile("(?:)", Pattern.COMMENTS | Pattern.UNIX_LINES); -// END android-change - isCompiled = true; - } catch (PatternSyntaxException e) { - System.out.println(e); - } - assertTrue(isCompiled); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testEmbeddedFlags() { - String baseString = "(?i)((?s)a)"; - String testString = "A"; - Pattern pat = Pattern.compile(baseString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?x)(?i)(?s)(?d)a"; - testString = "A"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "(?x)(?i)(?s)(?d)a."; - testString = "a\n"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "abc(?x:(?i)(?s)(?d)a.)"; - testString = "abcA\n"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - baseString = "abc((?x)d)(?i)(?s)a"; - testString = "abcdA"; - pat = Pattern.compile(baseString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testAltWithFlags() { - boolean isCompiled = false; - - try { - Pattern pat = Pattern.compile("|(?i-xi)|()"); - isCompiled = true; - } catch (PatternSyntaxException e) { - System.out.println(e); - } - assertTrue(isCompiled); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) -public void testRestoreFlagsAfterGroup() { - String baseString = "abc((?x)d) a"; - String testString = "abcd a"; - Pattern pat = Pattern.compile(baseString); - Matcher mat = pat.matcher(testString); - - assertTrue(mat.matches()); - } - - /* - * Verify if the Pattern support the following character classes: - * \p{javaLowerCase} \p{javaUpperCase} \p{javaWhitespace} \p{javaMirrored} - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) method.", - method = "compile", - args = {java.lang.String.class} - ) - public void testCompileCharacterClass() { - // Regression for HARMONY-606, 696 - Pattern pattern = Pattern.compile("\\p{javaLowerCase}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaUpperCase}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaWhitespace}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaMirrored}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaDefined}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaDigit}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaIdentifierIgnorable}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaISOControl}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaJavaIdentifierPart}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaJavaIdentifierStart}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaLetter}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaLetterOrDigit}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaSpaceChar}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaTitleCase}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaUnicodeIdentifierPart}"); - assertNotNull(pattern); - - pattern = Pattern.compile("\\p{javaUnicodeIdentifierStart}"); - assertNotNull(pattern); - } - - /** - * s original test was fixed to pass on RI - */ - -// BEGIN android-removed -// We don't have canonical equivalence. -// public void testCanonEqFlag() { -// -// /* -// * for decompositions see -// * http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt -// * http://www.unicode.org/reports/tr15/#Decomposition -// */ -// String baseString; -// String testString; -// Pattern pat; -// Matcher mat; -// -// baseString = "ab(a*)\\1"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// baseString = "a(abcdf)d"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// baseString = "aabcdfd"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// // \u01E0 -> \u0226\u0304 ->\u0041\u0307\u0304 -// // \u00CC -> \u0049\u0300 -// -// /* -// * baseString = "\u01E0\u00CCcdb(ac)"; testString = -// * "\u0226\u0304\u0049\u0300cdbac"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// */ -// baseString = "\u01E0cdb(a\u00CCc)"; -// testString = "\u0041\u0307\u0304cdba\u0049\u0300c"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// baseString = "a\u00CC"; -// testString = "a\u0049\u0300"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// /* -// * baseString = "\u0226\u0304cdb(ac\u0049\u0300)"; testString = -// * "\u01E0cdbac\u00CC"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "cdb(?:\u0041\u0307\u0304\u00CC)"; testString = -// * "cdb\u0226\u0304\u0049\u0300"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "\u01E0[a-c]\u0049\u0300cdb(ac)"; testString = -// * "\u01E0b\u00CCcdbac"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "\u01E0|\u00CCcdb(ac)"; testString = -// * "\u0041\u0307\u0304"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "\u00CC?cdb(ac)*(\u01E0)*[a-c]"; testString = -// * "cdb\u0041\u0307\u0304b"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// */ -// baseString = "a\u0300"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher("a\u00E0a"); -// assertTrue(mat.find()); -// -// /* -// * baseString = "\u7B20\uF9F8abc"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher("\uF9F8\uF9F8abc"); -// * assertTrue(mat.matches()); -// * -// * //\u01F9 -> \u006E\u0300 //\u00C3 -> \u0041\u0303 -// * -// * baseString = "cdb(?:\u00C3\u006E\u0300)"; testString = -// * "cdb\u0041\u0303\u01F9"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * //\u014C -> \u004F\u0304 //\u0163 -> \u0074\u0327 -// * -// * baseString = "cdb(?:\u0163\u004F\u0304)"; testString = -// * "cdb\u0074\u0327\u014C"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// */ -// // \u00E1->a\u0301 -// // canonical ordering takes place \u0301\u0327 -> \u0327\u0301 -// baseString = "c\u0327\u0301"; -// testString = "c\u0301\u0327"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// /* -// * Hangul decompositions -// */ -// // \uD4DB->\u1111\u1171\u11B6 -// // \uD21E->\u1110\u116D\u11B5 -// // \uD264->\u1110\u1170 -// // not Hangul:\u0453->\u0433\u0301 -// baseString = "a\uD4DB\u1111\u1171\u11B6\uD264"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// baseString = "\u0453c\uD4DB"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// baseString = "a\u1110\u116D\u11B5b\uD21Ebc"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// -// /* -// * baseString = "\uD4DB\uD21E\u1110\u1170cdb(ac)"; testString = -// * "\u1111\u1171\u11B6\u1110\u116D\u11B5\uD264cdbac"; pat = -// * Pattern.compile(baseString, Pattern.CANON_EQ); mat = -// * pat.matcher(testString); assertTrue(mat.matches()); -// */ -// baseString = "\uD4DB\uD264cdb(a\uD21Ec)"; -// testString = "\u1111\u1171\u11B6\u1110\u1170cdba\u1110\u116D\u11B5c"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// baseString = "a\uD4DB"; -// testString = "a\u1111\u1171\u11B6"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// baseString = "a\uD21E"; -// testString = "a\u1110\u116D\u11B5"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// /* -// * baseString = "\u1111\u1171\u11B6cdb(ac\u1110\u116D\u11B5)"; -// * testString = "\uD4DBcdbac\uD21E"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "cdb(?:\u1111\u1171\u11B6\uD21E)"; testString = -// * "cdb\uD4DB\u1110\u116D\u11B5"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * baseString = "\uD4DB[a-c]\u1110\u116D\u11B5cdb(ac)"; testString = -// * "\uD4DBb\uD21Ecdbac"; pat = Pattern.compile(baseString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// */ -// baseString = "\uD4DB|\u00CCcdb(ac)"; -// testString = "\u1111\u1171\u11B6"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// baseString = "\uD4DB|\u00CCcdb(ac)"; -// testString = "\u1111\u1171"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertFalse(mat.matches()); -// -// baseString = "\u00CC?cdb(ac)*(\uD4DB)*[a-c]"; -// testString = "cdb\u1111\u1171\u11B6b"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// -// baseString = "\uD4DB"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher("a\u1111\u1171\u11B6a"); -// assertTrue(mat.find()); -// -// baseString = "\u1111"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher("bcda\uD4DBr"); -// assertFalse(mat.find()); -// } -// -// /** -// * s original test was fixed to pass on RI -// */ -// -// public void testIndexesCanonicalEq() { -// String baseString; -// String testString; -// Pattern pat; -// Matcher mat; -// -// baseString = "\uD4DB"; -// pat = Pattern.compile(baseString, Pattern.CANON_EQ); -// mat = pat.matcher("bcda\u1111\u1171\u11B6awr"); -// assertTrue(mat.find()); -// assertEquals(mat.start(), 4); -// assertEquals(mat.end(), 7); -// -// /* -// * baseString = "\uD4DB\u1111\u1171\u11B6"; pat = -// * Pattern.compile(baseString, Pattern.CANON_EQ); mat = -// * pat.matcher("bcda\u1111\u1171\u11B6\uD4DBawr"); -// * assertTrue(mat.find()); assertEquals(mat.start(), 4); -// * assertEquals(mat.end(), 8); -// * -// * baseString = "\uD4DB\uD21E\u1110\u1170"; testString = -// * "abcabc\u1111\u1171\u11B6\u1110\u116D\u11B5\uD264cdbac"; pat = -// * Pattern.compile(baseString, Pattern.CANON_EQ); mat = -// * pat.matcher(testString); assertTrue(mat.find()); -// * assertEquals(mat.start(), 6); assertEquals(mat.end(), 13); -// */} -// -// /** -// * s original test was fixed to pass on RI -// */ -// -// public void testCanonEqFlagWithSupplementaryCharacters() { -// -// /* -// * \u1D1BF->\u1D1BB\u1D16F->\u1D1B9\u1D165\u1D16F in UTF32 -// * \uD834\uDDBF->\uD834\uDDBB\uD834\uDD6F -// * ->\uD834\uDDB9\uD834\uDD65\uD834\uDD6F in UTF16 -// */ -// String patString = "abc\uD834\uDDBFef"; -// String testString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef"; -// Pattern pat = Pattern.compile(patString, Pattern.CANON_EQ); -// Matcher mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// /* -// * testString = "abc\uD834\uDDBB\uD834\uDD6Fef"; mat = -// * pat.matcher(testString); assertTrue(mat.matches()); -// * -// * patString = "abc\uD834\uDDBB\uD834\uDD6Fef"; testString = -// * "abc\uD834\uDDBFef"; pat = Pattern.compile(patString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// */ -// testString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef"; -// mat = pat.matcher(testString); -// assertTrue(mat.matches()); -// /* -// * patString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef"; testString = -// * "abc\uD834\uDDBFef"; pat = Pattern.compile(patString, -// * Pattern.CANON_EQ); mat = pat.matcher(testString); -// * assertTrue(mat.matches()); -// * -// * testString = "abc\uD834\uDDBB\uD834\uDD6Fef"; mat = -// * pat.matcher(testString); assertTrue(mat.matches()); -// */ -// /* -// * testSupplementary characters with no decomposition -// */ -// /* -// * patString = "a\uD9A0\uDE8Ebc\uD834\uDDBB\uD834\uDD6Fe\uDE8Ef"; -// * testString = "a\uD9A0\uDE8Ebc\uD834\uDDBFe\uDE8Ef"; pat = -// * Pattern.compile(patString, Pattern.CANON_EQ); mat = -// * pat.matcher(testString); assertTrue(mat.matches()); -// */} -// END android-removed - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testRangesWithSurrogatesSupplementary() { - String patString = "[abc\uD8D2]"; - String testString = "\uD8D2"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "a"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "ef\uD8D2\uDD71gh"; - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "ef\uD8D2gh"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "[abc\uD8D3&&[c\uD8D3]]"; - testString = "c"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "a"; - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - testString = "ef\uD8D3\uDD71gh"; - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "ef\uD8D3gh"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "[abc\uD8D3\uDBEE\uDF0C&&[c\uD8D3\uDBEE\uDF0C]]"; - testString = "c"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uDBEE\uDF0C"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "ef\uD8D3\uDD71gh"; - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "ef\uD8D3gh"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "[abc\uDBFC]\uDDC2cd"; - testString = "\uDBFC\uDDC2cd"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - testString = "a\uDDC2cd"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testSequencesWithSurrogatesSupplementary() { - String patString = "abcd\uD8D3"; - String testString = "abcd\uD8D3\uDFFC"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); -// BEGIN android-changed -// This one really doesn't make sense, as the above is a corrupt surrogate. -// Even if it's matched by the JDK, it's more of a bug than of a behavior one -// might want to duplicate. -// assertFalse(mat.find()); -// END android-changed - testString = "abcd\uD8D3abc"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "ab\uDBEFcd"; - testString = "ab\uDBEFcd"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - patString = "\uDFFCabcd"; - testString = "\uD8D3\uDFFCabcd"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "abc\uDFFCabcdecd"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "\uD8D3\uDFFCabcd"; - testString = "abc\uD8D3\uD8D3\uDFFCabcd"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.find()); - } - - /** - * s original test was fixed to pass on RI - */ - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testPredefinedClassesWithSurrogatesSupplementary() { - String patString = "[123\\D]"; - String testString = "a"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.find()); - - testString = "5"; - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "3"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // low surrogate - testString = "\uDFC4"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // high surrogate - testString = "\uDADA"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - testString = "\uDADA\uDFC4"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "[123[^\\p{javaDigit}]]"; - testString = "a"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.find()); - - testString = "5"; - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "3"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // low surrogate - testString = "\uDFC4"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // high surrogate - testString = "\uDADA"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - testString = "\uDADA\uDFC4"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // surrogate characters - patString = "\\p{Cs}"; - testString = "\uD916\uDE27"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - - /* - * see http://www.unicode.org/reports/tr18/#Supplementary_Characters we - * have to treat text as code points not code units. \\p{Cs} matches any - * surrogate character but here testString is a one code point - * consisting of two code units (two surrogate characters) so we find - * nothing - */ - // assertFalse(mat.find()); - // swap low and high surrogates - testString = "\uDE27\uD916"; - mat = pat.matcher(testString); - assertTrue(mat.find()); - - patString = "[\uD916\uDE271\uD91623&&[^\\p{Cs}]]"; - testString = "1"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.find()); - - testString = "\uD916"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertFalse(mat.find()); - - testString = "\uD916\uDE27"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.find()); - - // \uD9A0\uDE8E=\u7828E - // \u78281=\uD9A0\uDE81 - patString = "[a-\uD9A0\uDE8E]"; - testString = "\uD9A0\uDE81"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testDotConstructionWithSurrogatesSupplementary() { - String patString = "."; - String testString = "\uD9A0\uDE81"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uDE81"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uD9A0"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\n"; - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - patString = ".*\uDE81"; - testString = "\uD9A0\uDE81\uD9A0\uDE81\uD9A0\uDE81"; - pat = Pattern.compile(patString); - mat = pat.matcher(testString); - assertFalse(mat.matches()); - - testString = "\uD9A0\uDE81\uD9A0\uDE81\uDE81"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - patString = ".*"; - testString = "\uD9A0\uDE81\n\uD9A0\uDE81\uD9A0\n\uDE81"; - pat = Pattern.compile(patString, Pattern.DOTALL); - mat = pat.matcher(testString); - assertTrue(mat.matches()); - } - - /** - * s java.util.regex.Pattern.quote(String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "quote", - args = {java.lang.String.class} - ) - public void test_quoteLjava_lang_String() { - for (String aPattern : testPatterns) { - Pattern p = Pattern.compile(aPattern); - try { - assertEquals("quote was wrong for plain text", "\\Qtest\\E", p - .quote("test")); - assertEquals("quote was wrong for text with quote sign", - "\\Q\\Qtest\\E", p.quote("\\Qtest")); - assertEquals("quote was wrong for quotted text", - "\\Q\\Qtest\\E\\\\E\\Q\\E", p.quote("\\Qtest\\E")); - } catch (Exception e) { - fail("Unexpected exception: " + e); - } - } - } - - /** - * s java.util.regex.Pattern.matcher(String, CharSequence) - * coped from test for matches method - */ - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void test_matcherLjava_lang_StringLjava_lang_CharSequence() { - String[][] posSeq = { - { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" }, - { "213567", "12324567", "1234567", "213213567", - "21312312312567", "444444567" }, - { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" }, - { "213234567", "3458", "0987654", "7689546432", "0398576", - "98432", "5" }, - { - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", - "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" }, - { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", - "abbbAbbbliceaaa", "Alice" }, - { "a123", "bnxnvgds156", "for", "while", "if", "struct" }, - { "xy" }, { "xy" }, { "xcy" } - - }; - - for (int i = 0; i < testPatterns.length; i++) { - for (int j = 0; j < posSeq[i].length; j++) { - assertTrue("Incorrect match: " + testPatterns[i] + " vs " - + posSeq[i][j], Pattern.compile(testPatterns[i]) - .matcher(posSeq[i][j]).matches()); - } - } - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testQuantifiersWithSurrogatesSupplementary() { - String patString = "\uD9A0\uDE81*abc"; - String testString = "\uD9A0\uDE81\uD9A0\uDE81abc"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "abc"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testAlternationsWithSurrogatesSupplementary() { - String patString = "\uDE81|\uD9A0\uDE81|\uD9A0"; - String testString = "\uD9A0"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uDE81"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uD9A0\uDE81"; - mat = pat.matcher(testString); - assertTrue(mat.matches()); - - testString = "\uDE81\uD9A0"; - mat = pat.matcher(testString); - assertFalse(mat.matches()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of compile(java.lang.String) & compile(java.lang.String, int) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testGroupsWithSurrogatesSupplementary() { - - //this pattern matches nothing - String patString = "(\uD9A0)\uDE81"; - String testString = "\uD9A0\uDE81"; - Pattern pat = Pattern.compile(patString); - Matcher mat = pat.matcher(testString); - assertFalse(mat.matches()); - - patString = "(\uD9A0)"; - testString = "\uD9A0\uDE81"; - pat = Pattern.compile(patString, Pattern.DOTALL); - mat = pat.matcher(testString); - assertFalse(mat.find()); - } - - /* - * Regression test for HARMONY-688 - */ - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "compile", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test verifies the functionality of compile(java.lang.String) & matcher(java.lang.CharSequence) methods.", - method = "matcher", - args = {java.lang.CharSequence.class} - ) - }) - public void testUnicodeCategoryWithSurrogatesSupplementary() { - Pattern p = Pattern.compile("\\p{javaLowerCase}"); - Matcher matcher = p.matcher("\uD801\uDC28"); - assertTrue(matcher.find()); - } - - public static void main(String[] args) { - junit.textui.TestRunner.run(PatternTest.class); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "The test doesn't verify Matcher and should be moved to PatterTest.", - method = "split", - args = {java.lang.CharSequence.class, int.class} - ) - public void testSplitEmpty() { - - Pattern pat = Pattern.compile(""); - String[] s = pat.split("", -1); - - assertEquals(1, s.length); - assertEquals("", s[0]); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void testToString() { - for (int i = 0; i < testPatterns.length; i++) { - Pattern p = Pattern.compile(testPatterns[i]); - assertEquals(testPatterns[i], p.toString()); - } - } - -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ReplaceTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ReplaceTest.java deleted file mode 100644 index 82390e7..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/ReplaceTest.java +++ /dev/null @@ -1,125 +0,0 @@ -/* 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.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import junit.framework.TestCase; -import java.util.regex.Pattern; -import java.util.regex.Matcher; -import java.util.regex.PatternSyntaxException; - -@TestTargetClass(Matcher.class) -public class ReplaceTest extends TestCase { - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of replaceFirst(java.lang.String) & replaceAll(java.lang.String) methods.", - method = "replaceFirst", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of replaceFirst(java.lang.String) & replaceAll(java.lang.String) methods.", - method = "replaceAll", - args = {java.lang.String.class} - ) - }) - public void testSimpleReplace() throws PatternSyntaxException { - String target, pattern, repl; - - target = "foobarfobarfoofo1barfort"; - pattern = "fo[^o]"; - repl = "xxx"; - - Pattern p = Pattern.compile(pattern); - Matcher m = p.matcher(target); - - assertEquals("foobarxxxarfoofo1barfort", m.replaceFirst(repl)); - assertEquals("foobarxxxarfooxxxbarxxxt", m.replaceAll(repl)); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of replaceFirst(java.lang.String) & replaceAll(java.lang.String) methods.", - method = "replaceFirst", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of replaceFirst(java.lang.String) & replaceAll(java.lang.String) methods.", - method = "replaceAll", - args = {java.lang.String.class} - ) - }) - public void testCaptureReplace() { - String target, pattern, repl, s; - Pattern p = null; - Matcher m; - - target = "[31]foo;bar[42];[99]xyz"; - pattern = "\\[([0-9]+)\\]([a-z]+)"; - repl = "$2[$1]"; - - p = Pattern.compile(pattern); - m = p.matcher(target); - s = m.replaceFirst(repl); - assertEquals("foo[31];bar[42];[99]xyz", s); - s = m.replaceAll(repl); - assertEquals("foo[31];bar[42];xyz[99]", s); - - target = "[31]foo(42)bar{63}zoo;[12]abc(34)def{56}ghi;{99}xyz[88]xyz(77)xyz;"; - pattern = "\\[([0-9]+)\\]([a-z]+)\\(([0-9]+)\\)([a-z]+)\\{([0-9]+)\\}([a-z]+)"; - repl = "[$5]$6($3)$4{$1}$2"; - p = Pattern.compile(pattern); - m = p.matcher(target); - s = m.replaceFirst(repl); - // System.out.println(s); - assertEquals("[63]zoo(42)bar{31}foo;[12]abc(34)def{56}ghi;{99}xyz[88]xyz(77)xyz;", s - ); - s = m.replaceAll(repl); - // System.out.println(s); - assertEquals("[63]zoo(42)bar{31}foo;[56]ghi(34)def{12}abc;{99}xyz[88]xyz(77)xyz;", s - ); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of replaceAll(java.lang.String) method with backslash chars.", - method = "replaceAll", - args = {java.lang.String.class} - ) - public void testEscapeReplace() { - String target, pattern, repl, s; - - target = "foo'bar''foo"; - pattern = "'"; - repl = "\\'"; - s = target.replaceAll(pattern, repl); - assertEquals("foo'bar''foo", s); - repl = "\\\\'"; - s = target.replaceAll(pattern, repl); - assertEquals("foo\\'bar\\'\\'foo", s); - repl = "\\$3"; - s = target.replaceAll(pattern, repl); - assertEquals("foo$3bar$3$3foo", s); - } -} diff --git a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/SplitTest.java b/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/SplitTest.java deleted file mode 100644 index ea615c0..0000000 --- a/regex/src/test/java/org/apache/harmony/regex/tests/java/util/regex/SplitTest.java +++ /dev/null @@ -1,201 +0,0 @@ -package org.apache.harmony.regex.tests.java.util.regex; - -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestLevel; - -import junit.framework.TestCase; -import java.util.regex.*; - -@TestTargetClass(java.util.regex.Pattern.class) -/** - * TODO Type description - * - */ -public class SplitTest extends TestCase { - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of split(java.lang.CharSequence) & compile(java.lang.String)methods.", - method = "split", - args = {java.lang.CharSequence.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the basic functionality of split(java.lang.CharSequence) & compile(java.lang.String)methods.", - method = "compile", - args = {java.lang.String.class} - ) - }) - public void testSimple() { - Pattern p = Pattern.compile("/"); - String[] results = p.split("have/you/done/it/right"); - String[] expected = new String[] { "have", "you", "done", "it", "right" }; - assertEquals(expected.length, results.length); - for (int i = 0; i < expected.length; i++) { - assertEquals(results[i], expected[i]); - } - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of split(java.lang.CharSequence). Test uses not empty pattern.", - method = "split", - args = {java.lang.CharSequence.class, int.class} - ) - public void testSplit1() throws PatternSyntaxException { - Pattern p = Pattern.compile(" "); - - String input = "poodle zoo"; - String tokens[]; - - tokens = p.split(input, 1); - assertEquals(1, tokens.length); - assertTrue(tokens[0].equals(input)); - tokens = p.split(input, 2); - assertEquals(2, tokens.length); - assertEquals("poodle", tokens[0]); - assertEquals("zoo", tokens[1]); - tokens = p.split(input, 5); - assertEquals(2, tokens.length); - assertEquals("poodle", tokens[0]); - assertEquals("zoo", tokens[1]); - tokens = p.split(input, -2); - assertEquals(2, tokens.length); - assertEquals("poodle", tokens[0]); - assertEquals("zoo", tokens[1]); - tokens = p.split(input, 0); - assertEquals(2, tokens.length); - assertEquals("poodle", tokens[0]); - assertEquals("zoo", tokens[1]); - tokens = p.split(input); - assertEquals(2, tokens.length); - assertEquals("poodle", tokens[0]); - assertEquals("zoo", tokens[1]); - - p = Pattern.compile("d"); - - tokens = p.split(input, 1); - assertEquals(1, tokens.length); - assertTrue(tokens[0].equals(input)); - tokens = p.split(input, 2); - assertEquals(2, tokens.length); - assertEquals("poo", tokens[0]); - assertEquals("le zoo", tokens[1]); - tokens = p.split(input, 5); - assertEquals(2, tokens.length); - assertEquals("poo", tokens[0]); - assertEquals("le zoo", tokens[1]); - tokens = p.split(input, -2); - assertEquals(2, tokens.length); - assertEquals("poo", tokens[0]); - assertEquals("le zoo", tokens[1]); - tokens = p.split(input, 0); - assertEquals(2, tokens.length); - assertEquals("poo", tokens[0]); - assertEquals("le zoo", tokens[1]); - tokens = p.split(input); - assertEquals(2, tokens.length); - assertEquals("poo", tokens[0]); - assertEquals("le zoo", tokens[1]); - - p = Pattern.compile("o"); - - tokens = p.split(input, 1); - assertEquals(1, tokens.length); - assertTrue(tokens[0].equals(input)); - tokens = p.split(input, 2); - assertEquals(2, tokens.length); - assertEquals("p", tokens[0]); - assertEquals("odle zoo", tokens[1]); - tokens = p.split(input, 5); - assertEquals(5, tokens.length); - assertEquals("p", tokens[0]); - assertTrue(tokens[1].equals("")); - assertEquals("dle z", tokens[2]); - assertTrue(tokens[3].equals("")); - assertTrue(tokens[4].equals("")); - tokens = p.split(input, -2); - assertEquals(5, tokens.length); - assertEquals("p", tokens[0]); - assertTrue(tokens[1].equals("")); - assertEquals("dle z", tokens[2]); - assertTrue(tokens[3].equals("")); - assertTrue(tokens[4].equals("")); - tokens = p.split(input, 0); - assertEquals(3, tokens.length); - assertEquals("p", tokens[0]); - assertTrue(tokens[1].equals("")); - assertEquals("dle z", tokens[2]); - tokens = p.split(input); - assertEquals(3, tokens.length); - assertEquals("p", tokens[0]); - assertTrue(tokens[1].equals("")); - assertEquals("dle z", tokens[2]); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of split(java.lang.CharSequence). Test uses empty pattern.", - method = "split", - args = {java.lang.CharSequence.class, int.class} - ) - public void testSplit2() { - Pattern p = Pattern.compile(""); - String s[]; - s = p.split("a", -1); - assertEquals(3, s.length); - assertEquals("", s[0]); - assertEquals("a", s[1]); - assertEquals("", s[2]); - - s = p.split("", -1); - assertEquals(1, s.length); - assertEquals("", s[0]); - - s = p.split("abcd", -1); - assertEquals(6, s.length); - assertEquals("", s[0]); - assertEquals("a", s[1]); - assertEquals("b", s[2]); - assertEquals("c", s[3]); - assertEquals("d", s[4]); - assertEquals("", s[5]); - - // Regression test for Android - assertEquals("GOOG,23,500".split("|").length, 12); - } - - - @TestTargets({ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of split(java.lang.CharSequence) & compile(java.lang.String, int) methods. Test uses empty pattern and supplementary chars.", - method = "split", - args = {java.lang.CharSequence.class, int.class} - ), - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies the functionality of split(java.lang.CharSequence) & compile(java.lang.String, int) methods. Test uses empty pattern and supplementary chars.", - method = "compile", - args = {java.lang.String.class} - ) - }) - public void testSplitSupplementaryWithEmptyString() { - - /* - * See http://www.unicode.org/reports/tr18/#Supplementary_Characters - * We have to treat text as code points not code units. - */ - Pattern p = Pattern.compile(""); - String s[]; - s = p.split("a\ud869\uded6b", -1); - assertEquals(5, s.length); - assertEquals("", s[0]); - assertEquals("a", s[1]); - assertEquals("\ud869\uded6", s[2]); - assertEquals("b", s[3]); - assertEquals("", s[4]); - } -} diff --git a/regex/src/test/java/tests/regex/AllTests.java b/regex/src/test/java/tests/regex/AllTests.java deleted file mode 100644 index d590d08..0000000 --- a/regex/src/test/java/tests/regex/AllTests.java +++ /dev/null @@ -1,38 +0,0 @@ -/* 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 tests.regex; - -import junit.framework.Test; -import junit.framework.TestSuite; - -/** - * Test suite that includes all tests for the regex project. - */ -public class AllTests { - - public static void main(String[] args) { - junit.textui.TestRunner.run(AllTests.suite()); - } - - public static Test suite() { - TestSuite suite = tests.TestSuiteFactory.createTestSuite("All regex test suites"); - // $JUnit-BEGIN$ - suite.addTest(org.apache.harmony.regex.tests.java.util.regex.AllTests.suite()); - // $JUnit-END$ - return suite; - } -} diff --git a/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.golden.ser b/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.golden.ser Binary files differdeleted file mode 100755 index 623d6ac..0000000 --- a/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternSyntaxExceptionTest.golden.ser +++ /dev/null diff --git a/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternTest.golden.ser b/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternTest.golden.ser Binary files differdeleted file mode 100755 index 6150adf..0000000 --- a/regex/src/test/resources/serialization/org/apache/harmony/regex/tests/java/util/regex/PatternTest.golden.ser +++ /dev/null |