Operations on Strings that contain words.
+ * + *This class tries to handle null input gracefully.
+ * An exception will not be thrown for a null input.
+ * Each method documents its behaviour in more detail.
WordUtils instances should NOT be constructed in
+ * standard programming. Instead, the class should be used as
+ * WordUtils.wrap("foo bar", 20);.
This constructor is public to permit tools that require a JavaBean + * instance to operate.
+ */ + public WordUtils() { + super(); + } + + // Wrapping + //-------------------------------------------------------------------------- + /** + *Wraps a single line of text, identifying words by ' '.
New lines will be separated by the system property line separator. + * Very long words, such as URLs will not be wrapped.
+ * + *Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLength | + *result | + *
|---|---|---|
| null | + ** | + *null | + *
| "" | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here, http://commons.apache.org, to jump to the commons website" | + *20 | + *"Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website" | + *
null if null input
+ */
+ public static String wrap(final String str, final int wrapLength) {
+ return wrap(str, wrapLength, null, false);
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by ' '.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *result | + *
|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + *null | + *
| "" | + ** | + ** | + *true/false | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @return a line with newlines inserted, null if null input
+ */
+ public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords) {
+ return wrap(str, wrapLength, newLineStr, wrapLongWords, " ");
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by wrapOn.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *wrapOn | + *result | + *
|---|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + ** | + *null | + *
| "" | + ** | + ** | + *true/false | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *" " | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *" " | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *" " | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
| "flammable/inflammable" | + *20 | + *"\n" | + *true | + *"/" | + *"flammable\ninflammable" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @param wrapOn regex expression to be used as a breakable characters,
+ * if blank string is provided a space character will be used
+ * @return a line with newlines inserted, null if null input
+ */
+/**
+ * Wraps a single line of text, identifying words by wrapOn.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *wrapOn | + *result | + *
|---|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + ** | + *null | + *
| "" | + ** | + ** | + *true/false | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *" " | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *" " | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *" " | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
| "flammable/inflammable" | + *20 | + *"\n" | + *true | + *"/" | + *"flammable\ninflammable" | + *
null uses the system property line separator
+ * @param wrapLongWords
+ * true if long words (such as URLs) should be wrapped
+ * @param wrapOn
+ * regex expression to be used as a breakable characters,
+ * if blank string is provided a space character will be used
+ * @return a line with newlines inserted, null if null input
+ */
+public static java.lang.String wrap(final java.lang.String str, int wrapLength, java.lang.String newLineStr, final boolean wrapLongWords, java.lang.String wrapOn) {
+ {
+ if (newLineStr == null) {
+ newLineStr = org.apache.commons.lang3.SystemUtils.LINE_SEPARATOR;
+ }
+ if (wrapLength < 1) {
+ wrapLength = 1;
+ }
+ if (org.apache.commons.lang3.StringUtils.isBlank(wrapOn)) {
+ wrapOn = " ";
+ }
+ java.util.regex.Pattern patternToWrapOn = java.util.regex.Pattern.compile(wrapOn);
+ final int inputLineLength = /* NPEX_NULL_EXP */
+ str.length();
+ int offset = 0;
+ final java.lang.StringBuilder wrappedLine = new java.lang.StringBuilder(inputLineLength + 32);
+ while (offset < inputLineLength) {
+ int spaceToWrapAt = -1;
+ java.util.regex.Matcher matcher = patternToWrapOn.matcher(str.substring(offset, java.lang.Math.min((offset + wrapLength) + 1, inputLineLength)));
+ if (matcher.find()) {
+ if (matcher.start() == 0) {
+ offset += matcher.end();
+ continue;
+ } else {
+ spaceToWrapAt = matcher.start();
+ }
+ }
+ // only last line without leading spaces is left
+ if ((inputLineLength - offset) <= wrapLength) {
+ break;
+ }
+ while (matcher.find()) {
+ spaceToWrapAt = matcher.start() + offset;
+ }
+ if (spaceToWrapAt >= offset) {
+ // normal case
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+ } else // really long word or URL
+ if (wrapLongWords) {
+ // wrap really long word one line at a time
+ wrappedLine.append(str.substring(offset, wrapLength + offset));
+ wrappedLine.append(newLineStr);
+ offset += wrapLength;
+ } else {
+ // do not wrap really long word, just extend beyond limit
+ matcher = patternToWrapOn.matcher(str.substring(offset + wrapLength));
+ if (matcher.find()) {
+ spaceToWrapAt = (matcher.start() + offset) + wrapLength;
+ }
+ if (spaceToWrapAt >= 0) {
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+ } else {
+ wrappedLine.append(str.substring(offset));
+ offset = inputLineLength;
+ }
+ }
+ }
+ // Whatever is left in line is short enough to just pass through
+ wrappedLine.append(str.substring(offset));
+ return wrappedLine.toString();
+ }
+}
+
+ // Capitalizing
+ //-----------------------------------------------------------------------
+ /**
+ * Capitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String)}.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null) = null
+ * WordUtils.capitalize("") = ""
+ * WordUtils.capitalize("i am FINE") = "I Am FINE"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ */
+ public static String capitalize(final String str) {
+ return capitalize(str, null);
+ }
+
+ /**
+ * Capitalizes all the delimiter separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String, char[])}.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null, *) = null
+ * WordUtils.capitalize("", *) = ""
+ * WordUtils.capitalize(*, new char[0]) = *
+ * WordUtils.capitalize("i am fine", null) = "I Am Fine"
+ * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ * @since 2.1
+ */
+ public static String capitalize(final String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean capitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (isDelimiter(ch, delimiters)) {
+ capitalizeNext = true;
+ } else if (capitalizeNext) {
+ buffer[i] = Character.toTitleCase(ch);
+ capitalizeNext = false;
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Converts all the whitespace separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null) = null
+ * WordUtils.capitalizeFully("") = ""
+ * WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ */
+ public static String capitalizeFully(final String str) {
+ return capitalizeFully(str, null);
+ }
+
+ /**
+ * Converts all the delimiter separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null, *) = null
+ * WordUtils.capitalizeFully("", *) = ""
+ * WordUtils.capitalizeFully(*, null) = *
+ * WordUtils.capitalizeFully(*, new char[0]) = *
+ * WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @since 2.1
+ */
+ public static String capitalizeFully(String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ str = str.toLowerCase();
+ return capitalize(str, delimiters);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null) = null
+ * WordUtils.uncapitalize("") = ""
+ * WordUtils.uncapitalize("I Am FINE") = "i am fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ */
+ public static String uncapitalize(final String str) {
+ return uncapitalize(str, null);
+ }
+
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be uncapitalized.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null, *) = null
+ * WordUtils.uncapitalize("", *) = ""
+ * WordUtils.uncapitalize(*, null) = *
+ * WordUtils.uncapitalize(*, new char[0]) = *
+ * WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @param delimiters set of characters to determine uncapitalization, null means whitespace
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ * @since 2.1
+ */
+ public static String uncapitalize(final String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean uncapitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (isDelimiter(ch, delimiters)) {
+ uncapitalizeNext = true;
+ } else if (uncapitalizeNext) {
+ buffer[i] = Character.toLowerCase(ch);
+ uncapitalizeNext = false;
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Swaps the case of a String using a word based algorithm.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * StringUtils.swapCase(null) = null
+ * StringUtils.swapCase("") = ""
+ * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
+ *
+ *
+ * @param str the String to swap case, may be null
+ * @return the changed String, null if null String input
+ */
+ public static String swapCase(final String str) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+
+ boolean whitespace = true;
+
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (Character.isUpperCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isTitleCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isLowerCase(ch)) {
+ if (whitespace) {
+ buffer[i] = Character.toTitleCase(ch);
+ whitespace = false;
+ } else {
+ buffer[i] = Character.toUpperCase(ch);
+ }
+ } else {
+ whitespace = Character.isWhitespace(ch);
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after whitespace are returned as a new string. + * Their case is not changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.initials(null) = null
+ * WordUtils.initials("") = ""
+ * WordUtils.initials("Ben John Lee") = "BJL"
+ * WordUtils.initials("Ben J.Lee") = "BJ"
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @return String of initial letters, null if null String input
+ * @see #initials(String,char[])
+ * @since 2.2
+ */
+ public static String initials(final String str) {
+ return initials(str, null);
+ }
+
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after the defined delimiters are returned as a new string. + * Their case is not changed.
+ * + *If the delimiters array is null, then Whitespace is used.
+ * Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * An empty delimiter array returns an empty String.
+ * WordUtils.initials(null, *) = null
+ * WordUtils.initials("", *) = ""
+ * WordUtils.initials("Ben John Lee", null) = "BJL"
+ * WordUtils.initials("Ben J.Lee", null) = "BJ"
+ * WordUtils.initials("Ben J.Lee", [' ','.']) = "BJL"
+ * WordUtils.initials(*, new char[0]) = ""
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @param delimiters set of characters to determine words, null means whitespace
+ * @return String of initial characters, null if null String input
+ * @see #initials(String)
+ * @since 2.2
+ */
+ public static String initials(final String str, final char... delimiters) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ if (delimiters != null && delimiters.length == 0) {
+ return StringUtils.EMPTY;
+ }
+ final int strLen = str.length();
+ final char[] buf = new char[strLen / 2 + 1];
+ int count = 0;
+ boolean lastWasGap = true;
+ for (int i = 0; i < strLen; i++) {
+ final char ch = str.charAt(i);
+
+ if (isDelimiter(ch, delimiters)) {
+ lastWasGap = true;
+ } else if (lastWasGap) {
+ buf[count++] = ch;
+ lastWasGap = false;
+ } else {
+ continue; // ignore ch
+ }
+ }
+ return new String(buf, 0, count);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks if the String contains all words in the given array.
+ * + *+ * A {@code null} String will return {@code false}. A {@code null}, zero + * length search array or if one element of array is null will return {@code false}. + *
+ * + *
+ * WordUtils.containsAllWords(null, *) = false
+ * WordUtils.containsAllWords("", *) = false
+ * WordUtils.containsAllWords(*, null) = false
+ * WordUtils.containsAllWords(*, []) = false
+ * WordUtils.containsAllWords("abcd", "ab", "cd") = false
+ * WordUtils.containsAllWords("abc def", "def", "abc") = true
+ *
+ *
+ *
+ * @param word The CharSequence to check, may be null
+ * @param words The array of String words to search for, may be null
+ * @return {@code true} if all search words are found, {@code false} otherwise
+ * @since 3.5
+ */
+ public static boolean containsAllWords(CharSequence word, CharSequence... words) {
+ if (StringUtils.isEmpty(word) || ArrayUtils.isEmpty(words)) {
+ return false;
+ }
+ for (CharSequence w : words) {
+ if (StringUtils.isBlank(w)) {
+ return false;
+ }
+ Pattern p = Pattern.compile(".*\\b" + w + "\\b.*");
+ if (!p.matcher(word).matches()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Is the character a delimiter.
+ *
+ * @param ch the character to check
+ * @param delimiters the delimiters
+ * @return true if it is a delimiter
+ */
+ private static boolean isDelimiter(final char ch, final char[] delimiters) {
+ if (delimiters == null) {
+ return Character.isWhitespace(ch);
+ }
+ for (final char delimiter : delimiters) {
+ if (ch == delimiter) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+}
diff --git a/Java/commons-lang-WordUtils_269/metadata.json b/Java/commons-lang-WordUtils_269/metadata.json
new file mode 100644
index 000000000..32cbb752a
--- /dev/null
+++ b/Java/commons-lang-WordUtils_269/metadata.json
@@ -0,0 +1,21 @@
+{
+ "language": "java",
+ "id": "commons-lang-WordUtils_269",
+ "buggyPath": ".",
+ "referencePath": null,
+ "buildCommand": "mvn package -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100 -DskipTests=true -DskipITs=true -Dtest=None -DfailIfNoTests=false",
+ "testCommand": "mvn test -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100",
+ "categories": [
+ "safety",
+ "npe"
+ ],
+ "npe": {
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 376,
+ "npe_method": "wrap",
+ "deref_field": "str",
+ "npe_class": "WordUtils",
+ "repo": "commons-lang",
+ "bug_id": "WordUtils_269"
+ }
+}
diff --git a/Java/commons-lang-WordUtils_269/npe.json b/Java/commons-lang-WordUtils_269/npe.json
new file mode 100644
index 000000000..3c99681c9
--- /dev/null
+++ b/Java/commons-lang-WordUtils_269/npe.json
@@ -0,0 +1,7 @@
+{
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 376,
+ "npe_method": "wrap",
+ "deref_field": "str",
+ "npe_class": "WordUtils"
+}
\ No newline at end of file
diff --git a/Java/commons-lang-WordUtils_403/Dockerfile b/Java/commons-lang-WordUtils_403/Dockerfile
new file mode 100644
index 000000000..7b7fbe349
--- /dev/null
+++ b/Java/commons-lang-WordUtils_403/Dockerfile
@@ -0,0 +1,18 @@
+FROM ghcr.io/kupl/starlab-benchmarks/java-base:commons-lang
+
+ENV TZ=Asia/Seoul
+
+COPY ./metadata.json .
+COPY ./npe.json .
+COPY ./buggy.java /tmp/buggy.java
+RUN export BUGGY_PATH=$(cat metadata.json | jq -r ".npe.filepath") \
+ && export BUGGY_LINE=$(cat metadata.json | jq -r ".npe.line") \
+ && export BUGGY_MTHD=$(cat metadata.json | jq -r ".npe.npe_method") \
+ && mv /tmp/buggy.java $BUGGY_PATH \
+ && echo "[{\"filepath\": \"$BUGGY_PATH\", \"line\": $BUGGY_LINE, \"method_name\": \"$BUGGY_MTHD\"}]" | jq . > traces.json
+
+RUN git init . && git add -A
+
+RUN $(cat metadata.json | jq -r ".buildCommand")
+
+RUN $(cat metadata.json | jq -r ".testCommand"); if [ $? -eq 0 ]; then exit 1; fi
diff --git a/Java/commons-lang-WordUtils_403/buggy.java b/Java/commons-lang-WordUtils_403/buggy.java
new file mode 100644
index 000000000..639a20aeb
--- /dev/null
+++ b/Java/commons-lang-WordUtils_403/buggy.java
@@ -0,0 +1,769 @@
+/*
+ * 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.commons.lang3.text;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
+
+/**
+ * Operations on Strings that contain words.
+ * + *This class tries to handle null input gracefully.
+ * An exception will not be thrown for a null input.
+ * Each method documents its behaviour in more detail.
WordUtils instances should NOT be constructed in
+ * standard programming. Instead, the class should be used as
+ * WordUtils.wrap("foo bar", 20);.
This constructor is public to permit tools that require a JavaBean + * instance to operate.
+ */ + public WordUtils() { + super(); + } + + // Wrapping + //-------------------------------------------------------------------------- + /** + *Wraps a single line of text, identifying words by ' '.
New lines will be separated by the system property line separator. + * Very long words, such as URLs will not be wrapped.
+ * + *Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLength | + *result | + *
|---|---|---|
| null | + ** | + *null | + *
| "" | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here, http://commons.apache.org, to jump to the commons website" | + *20 | + *"Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website" | + *
null if null input
+ */
+ public static String wrap(final String str, final int wrapLength) {
+ return wrap(str, wrapLength, null, false);
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by ' '.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *result | + *
|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + *null | + *
| "" | + ** | + ** | + *true/false | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @return a line with newlines inserted, null if null input
+ */
+ public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords) {
+ return wrap(str, wrapLength, newLineStr, wrapLongWords, " ");
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by wrapOn.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *wrapOn | + *result | + *
|---|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + ** | + *null | + *
| "" | + ** | + ** | + *true/false | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *" " | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *" " | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *" " | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
| "flammable/inflammable" | + *20 | + *"\n" | + *true | + *"/" | + *"flammable\ninflammable" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @param wrapOn regex expression to be used as a breakable characters,
+ * if blank string is provided a space character will be used
+ * @return a line with newlines inserted, null if null input
+ */
+ public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords, String wrapOn) {
+ if (str == null) {
+ return null;
+ }
+ if (newLineStr == null) {
+ newLineStr = SystemUtils.LINE_SEPARATOR;
+ }
+ if (wrapLength < 1) {
+ wrapLength = 1;
+ }
+ if (StringUtils.isBlank(wrapOn)) {
+ wrapOn = " ";
+ }
+ Pattern patternToWrapOn = Pattern.compile(wrapOn);
+ final int inputLineLength = str.length();
+ int offset = 0;
+ final StringBuilder wrappedLine = new StringBuilder(inputLineLength + 32);
+
+ while (offset < inputLineLength) {
+ int spaceToWrapAt = -1;
+ Matcher matcher = patternToWrapOn.matcher(str.substring(offset, Math.min(offset + wrapLength + 1, inputLineLength)));
+ if (matcher.find()) {
+ if (matcher.start() == 0) {
+ offset += matcher.end();
+ continue;
+ }else {
+ spaceToWrapAt = matcher.start();
+ }
+ }
+
+ // only last line without leading spaces is left
+ if(inputLineLength - offset <= wrapLength) {
+ break;
+ }
+
+ while(matcher.find()){
+ spaceToWrapAt = matcher.start() + offset;
+ }
+
+ if (spaceToWrapAt >= offset) {
+ // normal case
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+
+ } else {
+ // really long word or URL
+ if (wrapLongWords) {
+ // wrap really long word one line at a time
+ wrappedLine.append(str.substring(offset, wrapLength + offset));
+ wrappedLine.append(newLineStr);
+ offset += wrapLength;
+ } else {
+ // do not wrap really long word, just extend beyond limit
+ matcher = patternToWrapOn.matcher(str.substring(offset + wrapLength));
+ if (matcher.find()) {
+ spaceToWrapAt = matcher.start() + offset + wrapLength;
+ }
+
+ if (spaceToWrapAt >= 0) {
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+ } else {
+ wrappedLine.append(str.substring(offset));
+ offset = inputLineLength;
+ }
+ }
+ }
+ }
+
+ // Whatever is left in line is short enough to just pass through
+ wrappedLine.append(str.substring(offset));
+
+ return wrappedLine.toString();
+ }
+
+ // Capitalizing
+ //-----------------------------------------------------------------------
+ /**
+ * Capitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String)}.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null) = null
+ * WordUtils.capitalize("") = ""
+ * WordUtils.capitalize("i am FINE") = "I Am FINE"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ */
+ public static String capitalize(final String str) {
+ return capitalize(str, null);
+ }
+
+ /**
+ * Capitalizes all the delimiter separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String, char[])}.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null, *) = null
+ * WordUtils.capitalize("", *) = ""
+ * WordUtils.capitalize(*, new char[0]) = *
+ * WordUtils.capitalize("i am fine", null) = "I Am Fine"
+ * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ * @since 2.1
+ */
+/**
+ * Capitalizes all the delimiter separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String, char[])}.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null, *) = null
+ * WordUtils.capitalize("", *) = ""
+ * WordUtils.capitalize(*, new char[0]) = *
+ * WordUtils.capitalize("i am fine", null) = "I Am Fine"
+ * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine"
+ *
+ *
+ * @param str
+ * the String to capitalize, may be null
+ * @param delimiters
+ * set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ * @since 2.1
+ */
+public static java.lang.String capitalize(final java.lang.String str, final char... delimiters) {
+ final int delimLen = /* NPEX_NULL_EXP */
+ delimiters.length;
+ if (org.apache.commons.lang3.StringUtils.isEmpty(str) || (delimLen == 0)) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean capitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (org.apache.commons.lang3.text.WordUtils.isDelimiter(ch, delimiters)) {
+ capitalizeNext = true;
+ } else if (capitalizeNext) {
+ buffer[i] = java.lang.Character.toTitleCase(ch);
+ capitalizeNext = false;
+ }
+ }
+ return new java.lang.String(buffer);
+}
+
+ //-----------------------------------------------------------------------
+ /**
+ * Converts all the whitespace separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null) = null
+ * WordUtils.capitalizeFully("") = ""
+ * WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ */
+ public static String capitalizeFully(final String str) {
+ return capitalizeFully(str, null);
+ }
+
+ /**
+ * Converts all the delimiter separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null, *) = null
+ * WordUtils.capitalizeFully("", *) = ""
+ * WordUtils.capitalizeFully(*, null) = *
+ * WordUtils.capitalizeFully(*, new char[0]) = *
+ * WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @since 2.1
+ */
+ public static String capitalizeFully(String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ str = str.toLowerCase();
+ return capitalize(str, delimiters);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null) = null
+ * WordUtils.uncapitalize("") = ""
+ * WordUtils.uncapitalize("I Am FINE") = "i am fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ */
+ public static String uncapitalize(final String str) {
+ return uncapitalize(str, null);
+ }
+
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be uncapitalized.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null, *) = null
+ * WordUtils.uncapitalize("", *) = ""
+ * WordUtils.uncapitalize(*, null) = *
+ * WordUtils.uncapitalize(*, new char[0]) = *
+ * WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @param delimiters set of characters to determine uncapitalization, null means whitespace
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ * @since 2.1
+ */
+ public static String uncapitalize(final String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean uncapitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (isDelimiter(ch, delimiters)) {
+ uncapitalizeNext = true;
+ } else if (uncapitalizeNext) {
+ buffer[i] = Character.toLowerCase(ch);
+ uncapitalizeNext = false;
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Swaps the case of a String using a word based algorithm.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * StringUtils.swapCase(null) = null
+ * StringUtils.swapCase("") = ""
+ * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
+ *
+ *
+ * @param str the String to swap case, may be null
+ * @return the changed String, null if null String input
+ */
+ public static String swapCase(final String str) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+
+ boolean whitespace = true;
+
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (Character.isUpperCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isTitleCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isLowerCase(ch)) {
+ if (whitespace) {
+ buffer[i] = Character.toTitleCase(ch);
+ whitespace = false;
+ } else {
+ buffer[i] = Character.toUpperCase(ch);
+ }
+ } else {
+ whitespace = Character.isWhitespace(ch);
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after whitespace are returned as a new string. + * Their case is not changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.initials(null) = null
+ * WordUtils.initials("") = ""
+ * WordUtils.initials("Ben John Lee") = "BJL"
+ * WordUtils.initials("Ben J.Lee") = "BJ"
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @return String of initial letters, null if null String input
+ * @see #initials(String,char[])
+ * @since 2.2
+ */
+ public static String initials(final String str) {
+ return initials(str, null);
+ }
+
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after the defined delimiters are returned as a new string. + * Their case is not changed.
+ * + *If the delimiters array is null, then Whitespace is used.
+ * Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * An empty delimiter array returns an empty String.
+ * WordUtils.initials(null, *) = null
+ * WordUtils.initials("", *) = ""
+ * WordUtils.initials("Ben John Lee", null) = "BJL"
+ * WordUtils.initials("Ben J.Lee", null) = "BJ"
+ * WordUtils.initials("Ben J.Lee", [' ','.']) = "BJL"
+ * WordUtils.initials(*, new char[0]) = ""
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @param delimiters set of characters to determine words, null means whitespace
+ * @return String of initial characters, null if null String input
+ * @see #initials(String)
+ * @since 2.2
+ */
+ public static String initials(final String str, final char... delimiters) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ if (delimiters != null && delimiters.length == 0) {
+ return StringUtils.EMPTY;
+ }
+ final int strLen = str.length();
+ final char[] buf = new char[strLen / 2 + 1];
+ int count = 0;
+ boolean lastWasGap = true;
+ for (int i = 0; i < strLen; i++) {
+ final char ch = str.charAt(i);
+
+ if (isDelimiter(ch, delimiters)) {
+ lastWasGap = true;
+ } else if (lastWasGap) {
+ buf[count++] = ch;
+ lastWasGap = false;
+ } else {
+ continue; // ignore ch
+ }
+ }
+ return new String(buf, 0, count);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks if the String contains all words in the given array.
+ * + *+ * A {@code null} String will return {@code false}. A {@code null}, zero + * length search array or if one element of array is null will return {@code false}. + *
+ * + *
+ * WordUtils.containsAllWords(null, *) = false
+ * WordUtils.containsAllWords("", *) = false
+ * WordUtils.containsAllWords(*, null) = false
+ * WordUtils.containsAllWords(*, []) = false
+ * WordUtils.containsAllWords("abcd", "ab", "cd") = false
+ * WordUtils.containsAllWords("abc def", "def", "abc") = true
+ *
+ *
+ *
+ * @param word The CharSequence to check, may be null
+ * @param words The array of String words to search for, may be null
+ * @return {@code true} if all search words are found, {@code false} otherwise
+ * @since 3.5
+ */
+ public static boolean containsAllWords(CharSequence word, CharSequence... words) {
+ if (StringUtils.isEmpty(word) || ArrayUtils.isEmpty(words)) {
+ return false;
+ }
+ for (CharSequence w : words) {
+ if (StringUtils.isBlank(w)) {
+ return false;
+ }
+ Pattern p = Pattern.compile(".*\\b" + w + "\\b.*");
+ if (!p.matcher(word).matches()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Is the character a delimiter.
+ *
+ * @param ch the character to check
+ * @param delimiters the delimiters
+ * @return true if it is a delimiter
+ */
+ private static boolean isDelimiter(final char ch, final char[] delimiters) {
+ if (delimiters == null) {
+ return Character.isWhitespace(ch);
+ }
+ for (final char delimiter : delimiters) {
+ if (ch == delimiter) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+}
diff --git a/Java/commons-lang-WordUtils_403/metadata.json b/Java/commons-lang-WordUtils_403/metadata.json
new file mode 100644
index 000000000..079822e19
--- /dev/null
+++ b/Java/commons-lang-WordUtils_403/metadata.json
@@ -0,0 +1,21 @@
+{
+ "language": "java",
+ "id": "commons-lang-WordUtils_403",
+ "buggyPath": ".",
+ "referencePath": null,
+ "buildCommand": "mvn package -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100 -DskipTests=true -DskipITs=true -Dtest=None -DfailIfNoTests=false",
+ "testCommand": "mvn test -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100",
+ "categories": [
+ "safety",
+ "npe"
+ ],
+ "npe": {
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 435,
+ "npe_method": "capitalize",
+ "deref_field": "delimiters",
+ "npe_class": "WordUtils",
+ "repo": "commons-lang",
+ "bug_id": "WordUtils_403"
+ }
+}
diff --git a/Java/commons-lang-WordUtils_403/npe.json b/Java/commons-lang-WordUtils_403/npe.json
new file mode 100644
index 000000000..523b7d95d
--- /dev/null
+++ b/Java/commons-lang-WordUtils_403/npe.json
@@ -0,0 +1,7 @@
+{
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 435,
+ "npe_method": "capitalize",
+ "deref_field": "delimiters",
+ "npe_class": "WordUtils"
+}
\ No newline at end of file
diff --git a/Java/commons-lang-WordUtils_726/Dockerfile b/Java/commons-lang-WordUtils_726/Dockerfile
new file mode 100644
index 000000000..7b7fbe349
--- /dev/null
+++ b/Java/commons-lang-WordUtils_726/Dockerfile
@@ -0,0 +1,18 @@
+FROM ghcr.io/kupl/starlab-benchmarks/java-base:commons-lang
+
+ENV TZ=Asia/Seoul
+
+COPY ./metadata.json .
+COPY ./npe.json .
+COPY ./buggy.java /tmp/buggy.java
+RUN export BUGGY_PATH=$(cat metadata.json | jq -r ".npe.filepath") \
+ && export BUGGY_LINE=$(cat metadata.json | jq -r ".npe.line") \
+ && export BUGGY_MTHD=$(cat metadata.json | jq -r ".npe.npe_method") \
+ && mv /tmp/buggy.java $BUGGY_PATH \
+ && echo "[{\"filepath\": \"$BUGGY_PATH\", \"line\": $BUGGY_LINE, \"method_name\": \"$BUGGY_MTHD\"}]" | jq . > traces.json
+
+RUN git init . && git add -A
+
+RUN $(cat metadata.json | jq -r ".buildCommand")
+
+RUN $(cat metadata.json | jq -r ".testCommand"); if [ $? -eq 0 ]; then exit 1; fi
diff --git a/Java/commons-lang-WordUtils_726/buggy.java b/Java/commons-lang-WordUtils_726/buggy.java
new file mode 100644
index 000000000..48aef8624
--- /dev/null
+++ b/Java/commons-lang-WordUtils_726/buggy.java
@@ -0,0 +1,747 @@
+/*
+ * 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.commons.lang3.text;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
+
+/**
+ * Operations on Strings that contain words.
+ * + *This class tries to handle null input gracefully.
+ * An exception will not be thrown for a null input.
+ * Each method documents its behaviour in more detail.
WordUtils instances should NOT be constructed in
+ * standard programming. Instead, the class should be used as
+ * WordUtils.wrap("foo bar", 20);.
This constructor is public to permit tools that require a JavaBean + * instance to operate.
+ */ + public WordUtils() { + super(); + } + + // Wrapping + //-------------------------------------------------------------------------- + /** + *Wraps a single line of text, identifying words by ' '.
New lines will be separated by the system property line separator. + * Very long words, such as URLs will not be wrapped.
+ * + *Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLength | + *result | + *
|---|---|---|
| null | + ** | + *null | + *
| "" | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here, http://commons.apache.org, to jump to the commons website" | + *20 | + *"Click here,\nhttp://commons.apache.org,\nto jump to the\ncommons website" | + *
null if null input
+ */
+ public static String wrap(final String str, final int wrapLength) {
+ return wrap(str, wrapLength, null, false);
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by ' '.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *result | + *
|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + *null | + *
| "" | + ** | + ** | + *true/false | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @return a line with newlines inserted, null if null input
+ */
+ public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords) {
+ return wrap(str, wrapLength, newLineStr, wrapLongWords, " ");
+ }
+
+ /**
+ * Wraps a single line of text, identifying words by wrapOn.
Leading spaces on a new line are stripped. + * Trailing spaces are not stripped.
+ * + *| input | + *wrapLenght | + *newLineString | + *wrapLongWords | + *wrapOn | + *result | + *
|---|---|---|---|---|---|
| null | + ** | + ** | + *true/false | + ** | + *null | + *
| "" | + ** | + ** | + *true/false | + ** | + *"" | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"\n" | + *true/false | + *" " | + *"Here is one line of\ntext that is going\nto be wrapped after\n20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *"<br />" | + *true/false | + *" " | + *"Here is one line of<br />text that is going<br />to be wrapped after<br />20 columns." | + *
| "Here is one line of text that is going to be wrapped after 20 columns." | + *20 | + *null | + *true/false | + *" " | + *"Here is one line of" + systemNewLine + "text that is going" + systemNewLine + "to be wrapped after" + systemNewLine + "20 columns." | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *false | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apache.org" | + *
| "Click here to jump to the commons website - http://commons.apache.org" | + *20 | + *"\n" | + *true | + *" " | + *"Click here to jump\nto the commons\nwebsite -\nhttp://commons.apach\ne.org" | + *
| "flammable/inflammable" | + *20 | + *"\n" | + *true | + *"/" | + *"flammable\ninflammable" | + *
null uses the system property line separator
+ * @param wrapLongWords true if long words (such as URLs) should be wrapped
+ * @param wrapOn regex expression to be used as a breakable characters,
+ * if blank string is provided a space character will be used
+ * @return a line with newlines inserted, null if null input
+ */
+ public static String wrap(final String str, int wrapLength, String newLineStr, final boolean wrapLongWords, String wrapOn) {
+ if (str == null) {
+ return null;
+ }
+ if (newLineStr == null) {
+ newLineStr = SystemUtils.LINE_SEPARATOR;
+ }
+ if (wrapLength < 1) {
+ wrapLength = 1;
+ }
+ if (StringUtils.isBlank(wrapOn)) {
+ wrapOn = " ";
+ }
+ Pattern patternToWrapOn = Pattern.compile(wrapOn);
+ final int inputLineLength = str.length();
+ int offset = 0;
+ final StringBuilder wrappedLine = new StringBuilder(inputLineLength + 32);
+
+ while (offset < inputLineLength) {
+ int spaceToWrapAt = -1;
+ Matcher matcher = patternToWrapOn.matcher(str.substring(offset, Math.min(offset + wrapLength + 1, inputLineLength)));
+ if (matcher.find()) {
+ if (matcher.start() == 0) {
+ offset += matcher.end();
+ continue;
+ }else {
+ spaceToWrapAt = matcher.start();
+ }
+ }
+
+ // only last line without leading spaces is left
+ if(inputLineLength - offset <= wrapLength) {
+ break;
+ }
+
+ while(matcher.find()){
+ spaceToWrapAt = matcher.start() + offset;
+ }
+
+ if (spaceToWrapAt >= offset) {
+ // normal case
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+
+ } else {
+ // really long word or URL
+ if (wrapLongWords) {
+ // wrap really long word one line at a time
+ wrappedLine.append(str.substring(offset, wrapLength + offset));
+ wrappedLine.append(newLineStr);
+ offset += wrapLength;
+ } else {
+ // do not wrap really long word, just extend beyond limit
+ matcher = patternToWrapOn.matcher(str.substring(offset + wrapLength));
+ if (matcher.find()) {
+ spaceToWrapAt = matcher.start() + offset + wrapLength;
+ }
+
+ if (spaceToWrapAt >= 0) {
+ wrappedLine.append(str.substring(offset, spaceToWrapAt));
+ wrappedLine.append(newLineStr);
+ offset = spaceToWrapAt + 1;
+ } else {
+ wrappedLine.append(str.substring(offset));
+ offset = inputLineLength;
+ }
+ }
+ }
+ }
+
+ // Whatever is left in line is short enough to just pass through
+ wrappedLine.append(str.substring(offset));
+
+ return wrappedLine.toString();
+ }
+
+ // Capitalizing
+ //-----------------------------------------------------------------------
+ /**
+ * Capitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String)}.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null) = null
+ * WordUtils.capitalize("") = ""
+ * WordUtils.capitalize("i am FINE") = "I Am FINE"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ */
+ public static String capitalize(final String str) {
+ return capitalize(str, null);
+ }
+
+ /**
+ * Capitalizes all the delimiter separated words in a String. + * Only the first character of each word is changed. To convert the + * rest of each word to lowercase at the same time, + * use {@link #capitalizeFully(String, char[])}.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalize(null, *) = null
+ * WordUtils.capitalize("", *) = ""
+ * WordUtils.capitalize(*, new char[0]) = *
+ * WordUtils.capitalize("i am fine", null) = "I Am Fine"
+ * WordUtils.capitalize("i aM.fine", {'.'}) = "I aM.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @see #uncapitalize(String)
+ * @see #capitalizeFully(String)
+ * @since 2.1
+ */
+ public static String capitalize(final String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean capitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (isDelimiter(ch, delimiters)) {
+ capitalizeNext = true;
+ } else if (capitalizeNext) {
+ buffer[i] = Character.toTitleCase(ch);
+ capitalizeNext = false;
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Converts all the whitespace separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null) = null
+ * WordUtils.capitalizeFully("") = ""
+ * WordUtils.capitalizeFully("i am FINE") = "I Am Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @return capitalized String, null if null String input
+ */
+ public static String capitalizeFully(final String str) {
+ return capitalizeFully(str, null);
+ }
+
+ /**
+ * Converts all the delimiter separated words in a String into capitalized words, + * that is each word is made up of a titlecase character and then a series of + * lowercase characters.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be capitalized.
+ * + *A null input String returns null.
+ * Capitalization uses the Unicode title case, normally equivalent to
+ * upper case.
+ * WordUtils.capitalizeFully(null, *) = null
+ * WordUtils.capitalizeFully("", *) = ""
+ * WordUtils.capitalizeFully(*, null) = *
+ * WordUtils.capitalizeFully(*, new char[0]) = *
+ * WordUtils.capitalizeFully("i aM.fine", {'.'}) = "I am.Fine"
+ *
+ *
+ * @param str the String to capitalize, may be null
+ * @param delimiters set of characters to determine capitalization, null means whitespace
+ * @return capitalized String, null if null String input
+ * @since 2.1
+ */
+ public static String capitalizeFully(String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ str = str.toLowerCase();
+ return capitalize(str, delimiters);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null) = null
+ * WordUtils.uncapitalize("") = ""
+ * WordUtils.uncapitalize("I Am FINE") = "i am fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ */
+ public static String uncapitalize(final String str) {
+ return uncapitalize(str, null);
+ }
+
+ /**
+ * Uncapitalizes all the whitespace separated words in a String. + * Only the first character of each word is changed.
+ * + *The delimiters represent a set of characters understood to separate words. + * The first string character and the first non-delimiter character after a + * delimiter will be uncapitalized.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.uncapitalize(null, *) = null
+ * WordUtils.uncapitalize("", *) = ""
+ * WordUtils.uncapitalize(*, null) = *
+ * WordUtils.uncapitalize(*, new char[0]) = *
+ * WordUtils.uncapitalize("I AM.FINE", {'.'}) = "i AM.fINE"
+ *
+ *
+ * @param str the String to uncapitalize, may be null
+ * @param delimiters set of characters to determine uncapitalization, null means whitespace
+ * @return uncapitalized String, null if null String input
+ * @see #capitalize(String)
+ * @since 2.1
+ */
+ public static String uncapitalize(final String str, final char... delimiters) {
+ final int delimLen = delimiters == null ? -1 : delimiters.length;
+ if (StringUtils.isEmpty(str) || delimLen == 0) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+ boolean uncapitalizeNext = true;
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (isDelimiter(ch, delimiters)) {
+ uncapitalizeNext = true;
+ } else if (uncapitalizeNext) {
+ buffer[i] = Character.toLowerCase(ch);
+ uncapitalizeNext = false;
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Swaps the case of a String using a word based algorithm.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * StringUtils.swapCase(null) = null
+ * StringUtils.swapCase("") = ""
+ * StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
+ *
+ *
+ * @param str the String to swap case, may be null
+ * @return the changed String, null if null String input
+ */
+ public static String swapCase(final String str) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ final char[] buffer = str.toCharArray();
+
+ boolean whitespace = true;
+
+ for (int i = 0; i < buffer.length; i++) {
+ final char ch = buffer[i];
+ if (Character.isUpperCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isTitleCase(ch)) {
+ buffer[i] = Character.toLowerCase(ch);
+ whitespace = false;
+ } else if (Character.isLowerCase(ch)) {
+ if (whitespace) {
+ buffer[i] = Character.toTitleCase(ch);
+ whitespace = false;
+ } else {
+ buffer[i] = Character.toUpperCase(ch);
+ }
+ } else {
+ whitespace = Character.isWhitespace(ch);
+ }
+ }
+ return new String(buffer);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after whitespace are returned as a new string. + * Their case is not changed.
+ * + *Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * WordUtils.initials(null) = null
+ * WordUtils.initials("") = ""
+ * WordUtils.initials("Ben John Lee") = "BJL"
+ * WordUtils.initials("Ben J.Lee") = "BJ"
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @return String of initial letters, null if null String input
+ * @see #initials(String,char[])
+ * @since 2.2
+ */
+ public static String initials(final String str) {
+ return initials(str, null);
+ }
+
+ /**
+ * Extracts the initial characters from each word in the String.
+ * + *All first characters after the defined delimiters are returned as a new string. + * Their case is not changed.
+ * + *If the delimiters array is null, then Whitespace is used.
+ * Whitespace is defined by {@link Character#isWhitespace(char)}.
+ * A null input String returns null.
+ * An empty delimiter array returns an empty String.
+ * WordUtils.initials(null, *) = null
+ * WordUtils.initials("", *) = ""
+ * WordUtils.initials("Ben John Lee", null) = "BJL"
+ * WordUtils.initials("Ben J.Lee", null) = "BJ"
+ * WordUtils.initials("Ben J.Lee", [' ','.']) = "BJL"
+ * WordUtils.initials(*, new char[0]) = ""
+ *
+ *
+ * @param str the String to get initials from, may be null
+ * @param delimiters set of characters to determine words, null means whitespace
+ * @return String of initial characters, null if null String input
+ * @see #initials(String)
+ * @since 2.2
+ */
+ public static String initials(final String str, final char... delimiters) {
+ if (StringUtils.isEmpty(str)) {
+ return str;
+ }
+ if (delimiters != null && delimiters.length == 0) {
+ return StringUtils.EMPTY;
+ }
+ final int strLen = str.length();
+ final char[] buf = new char[strLen / 2 + 1];
+ int count = 0;
+ boolean lastWasGap = true;
+ for (int i = 0; i < strLen; i++) {
+ final char ch = str.charAt(i);
+
+ if (isDelimiter(ch, delimiters)) {
+ lastWasGap = true;
+ } else if (lastWasGap) {
+ buf[count++] = ch;
+ lastWasGap = false;
+ } else {
+ continue; // ignore ch
+ }
+ }
+ return new String(buf, 0, count);
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Checks if the String contains all words in the given array.
+ * + *+ * A {@code null} String will return {@code false}. A {@code null}, zero + * length search array or if one element of array is null will return {@code false}. + *
+ * + *
+ * WordUtils.containsAllWords(null, *) = false
+ * WordUtils.containsAllWords("", *) = false
+ * WordUtils.containsAllWords(*, null) = false
+ * WordUtils.containsAllWords(*, []) = false
+ * WordUtils.containsAllWords("abcd", "ab", "cd") = false
+ * WordUtils.containsAllWords("abc def", "def", "abc") = true
+ *
+ *
+ *
+ * @param word The CharSequence to check, may be null
+ * @param words The array of String words to search for, may be null
+ * @return {@code true} if all search words are found, {@code false} otherwise
+ * @since 3.5
+ */
+ public static boolean containsAllWords(CharSequence word, CharSequence... words) {
+ if (StringUtils.isEmpty(word) || ArrayUtils.isEmpty(words)) {
+ return false;
+ }
+ for (CharSequence w : words) {
+ if (StringUtils.isBlank(w)) {
+ return false;
+ }
+ Pattern p = Pattern.compile(".*\\b" + w + "\\b.*");
+ if (!p.matcher(word).matches()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ //-----------------------------------------------------------------------
+ /**
+ * Is the character a delimiter.
+ *
+ * @param ch the character to check
+ * @param delimiters the delimiters
+ * @return true if it is a delimiter
+ */
+// -----------------------------------------------------------------------
+/**
+ * Is the character a delimiter.
+ *
+ * @param ch
+ * the character to check
+ * @param delimiters
+ * the delimiters
+ * @return true if it is a delimiter
+ */
+private static boolean isDelimiter(final char ch, final char[] delimiters) {
+ {
+ for (final char delimiter : /* NPEX_NULL_EXP */
+ delimiters) {
+ if (ch == delimiter) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
+
+}
diff --git a/Java/commons-lang-WordUtils_726/metadata.json b/Java/commons-lang-WordUtils_726/metadata.json
new file mode 100644
index 000000000..77a11f8cd
--- /dev/null
+++ b/Java/commons-lang-WordUtils_726/metadata.json
@@ -0,0 +1,21 @@
+{
+ "language": "java",
+ "id": "commons-lang-WordUtils_726",
+ "buggyPath": ".",
+ "referencePath": null,
+ "buildCommand": "mvn package -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100 -DskipTests=true -DskipITs=true -Dtest=None -DfailIfNoTests=false",
+ "testCommand": "mvn test -V -B -Denforcer.skip=true -Dcheckstyle.skip=true -Dcobertura.skip=true -Drat.skip=true -Dlicense.skip=true -Dfindbugs.skip=true -Dgpg.skip=true -Dskip.npm=true -Dskip.gulp=true -Dskip.bower=true -Drat.numUnapprovedLicenses=100",
+ "categories": [
+ "safety",
+ "npe"
+ ],
+ "npe": {
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 738,
+ "npe_method": "isDelimiter",
+ "deref_field": "delimiters",
+ "npe_class": "WordUtils",
+ "repo": "commons-lang",
+ "bug_id": "WordUtils_726"
+ }
+}
diff --git a/Java/commons-lang-WordUtils_726/npe.json b/Java/commons-lang-WordUtils_726/npe.json
new file mode 100644
index 000000000..50b1ad590
--- /dev/null
+++ b/Java/commons-lang-WordUtils_726/npe.json
@@ -0,0 +1,7 @@
+{
+ "filepath": "src/main/java/org/apache/commons/lang3/text/WordUtils.java",
+ "line": 738,
+ "npe_method": "isDelimiter",
+ "deref_field": "delimiters",
+ "npe_class": "WordUtils"
+}
\ No newline at end of file