asfgit closed pull request #846: GROOVY-8939: Add methods in StringGroovyMethods for better API Usage URL: https://github.com/apache/groovy/pull/846
This is a PR merged from a forked repository. As GitHub hides the original diff on merge, it is displayed below for the sake of provenance: As this is a foreign pull request (from a fork), the diff is supplied below (as it won't show otherwise due to GitHub magic): diff --git a/src/main/java/org/codehaus/groovy/runtime/StringGroovyMethods.java b/src/main/java/org/codehaus/groovy/runtime/StringGroovyMethods.java index ddca930f99..66b886ce6e 100644 --- a/src/main/java/org/codehaus/groovy/runtime/StringGroovyMethods.java +++ b/src/main/java/org/codehaus/groovy/runtime/StringGroovyMethods.java @@ -3888,4 +3888,520 @@ public static boolean isBlank(CharSequence self) { return self.toString().matches("\\s*"); } + + /** + * Returns the last <code>num</code> elements from this CharSequence. + * <pre class="groovyTestCase"> + * def text = "Groovy" + * assert text.takeRight( 0 ) == '' + * assert text.takeRight( 2 ) == 'vy' + * assert text.takeRight( 7 ) == 'Groovy' + * </pre> + * + * @param self the original CharSequence + * @param num the number of chars to take from this CharSequence from the right + * @return a CharSequence consisting of the last <code>num</code> chars, + * or else the whole CharSequence if it has less than <code>num</code> elements. + * @since 3.0.0 + */ + public static CharSequence takeRight(CharSequence self, int num) { + if (num < 0) + return self.subSequence(0, 0); + + int begin = Math.max(0, self.length() - num); + return self.subSequence(begin, self.length()); + } + + /** + * A GString variant of the equivalent CharSequence method {@link #takeRight(CharSequence, int)} + * + * @param self the original CharSequence + * @param num the number of chars to take from this CharSequence from the right + * @return a String consisting of the last <code>num</code> chars, + * or else the whole CharSequence if it has less than <code>num</code> elements. + * @since 3.0.0 + */ + public static String takeRight(String self, int num) { + return (String) takeRight((CharSequence) self, num); + } + + /** + * A String variant of the equivalent CharSequence method {@link #takeRight(CharSequence, int)} + * + * @param self the original GString + * @param num the number of chars to take from this GString from the right + * @return a String consisting of the last <code>num</code> chars, + * or else the whole GString if it has less than <code>num</code> elements. + * @since 3.0.0 + */ + public static String takeRight(GString self, int num) { + return takeRight(self.toString(), num); + } + + /** + * Returns the {@code CharSequence} that exists after the first occurrence of the given + * {@code searchString} in this CharSequence + * + * <pre class="groovyTestCase"> + * def text = "Groovy development. Groovy team" + * assert text.takeAfter( 'Groovy' ) == ' development. Groovy team' + * assert text.takeAfter( 'team' ) == '' + * assert text.takeAfter( '' ) == '' + * assert text.takeAfter( 'Unavailable text' ) == '' + * assert text.takeAfter( null ) == '' + * </pre> + * + * @param self the original CharSequence + * @param searchString CharSequence that is searched in this CharSequence + * @return CharSequence that is after the given searchString and empty string if it does not exist + * @since 3.0.0 + */ + public static CharSequence takeAfter(CharSequence self, CharSequence searchString) { + if (searchString == null || searchString.toString().isEmpty() || self.length() <= searchString.length()) + return self.subSequence(0, 0); + + String s = self.toString(); + + int index = s.indexOf(searchString.toString()); + + return (index == -1) ? self.subSequence(0, 0) : self.subSequence(index + searchString.length(), self.length()); + } + + /** + * A String variant of the equivalent CharSequence method {@link #takeAfter(CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param searchString String that is searched in this CharSequence + * @return String that is after the given searchString and empty string if it does not exist + * @since 3.0.0 + */ + public static String takeAfter(String self, CharSequence searchString) { + return (String) takeAfter((CharSequence) self, searchString); + } + + /** + * A GString variant of the equivalent CharSequence method {@link #takeAfter(CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param searchString CharSequence that is searched in this CharSequence + * @return String that is after the given searchString and empty string if it does not exist + * @since 3.0.0 + */ + public static String takeAfter(GString self, CharSequence searchString) { + return takeAfter(self.toString(), searchString); + } + + /** + * Returns the {@code CharSequence} that exists before the first occurrence of the given + * {@code searchString} in this CharSequence + * + * <pre class="groovyTestCase"> + * def text = "Groovy development. Groovy team" + * + * assert text.takeBefore( ' Groovy ' ) == 'Groovy development.' + * assert text.takeBefore( ' ' ) == 'Groovy' + * assert text.takeBefore( 'Unavailable text' ) == '' + * assert text.takeBefore( null ) == '' + * </pre> + * + * @param self the original CharSequence + * @param searchString CharSequence that is searched in this CharSequence + * @return CharSequence that is before the given searchString + * @since 3.0.0 + */ + public static CharSequence takeBefore(CharSequence self, CharSequence searchString) { + if (searchString == null || searchString.toString().isEmpty() || self.length() <= searchString.length()) + return self.subSequence(0, 0); + + String s = self.toString(); + + int index = s.indexOf(searchString.toString()); + + return (index == -1) ? self.subSequence(0, 0) : self.subSequence(0, index); + } + + /** + * A GString variant of the equivalent CharSequence method {@link #takeBefore(CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param searchString CharSequence that is searched in this CharSequence + * @return String that is before the given searchString + * @since 3.0.0 + */ + public static String takeBefore(GString self, String searchString) { + return takeBefore(self.toString(), searchString); + } + + /** + * A String variant of the equivalent CharSequence method {@link #takeBefore(CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param searchString CharSequence that is searched in this CharSequence + * @return String that is before the given searchString + * @since 3.0.0 + */ + public static String takeBefore(String self, String searchString) { + return (String) takeBefore((CharSequence) self, searchString); + } + + /** + * The method returns new CharSequence after removing the right {@code num} chars. Returns empty String if the + * {@code num} is greater than the length of the CharSequence + * + * <pre class="groovyTestCase"> + * def text = "groovy" + * + * assert text.dropRight( 3 ) == 'gro' + * assert text.dropRight( 6 ) == '' + * assert text.dropRight( 0 ) == 'groovy' + * assert text.dropRight( -1 ) == 'groovy' + * assert text.dropRight( 10 ) == '' + * + * </pre> + * + * @param self the original CharSequence + * @param num number of characters + * @return CharSequence after removing the right {@code num} chars and empty of the {@code num} is greater than the + * length of the CharSequence + * @since 3.0.0 + */ + public static CharSequence dropRight(CharSequence self, int num) { + + if (num < 0) + return self; + + if (num >= self.length()) + return self.subSequence(0, 0); + + return take(self, self.length() - num); + } + + /** + * A String variant of the equivalent CharSequence method {@link #dropRight(CharSequence, int)} + * + * @param self the original CharSequence + * @param num number of characters + * @return String after removing the right {@code num} chars and empty of the {@code num} is greater than the + * length of the CharSequence + * @since 3.0.0 + */ + public static String dropRight(String self, int num) { + return (String) dropRight((CharSequence) self, num); + } + + + /** + * A GString variant of the equivalent CharSequence method {@link #dropRight(CharSequence, int)} + * + * @param self the original CharSequence + * @param num number of characters + * @return String after removing the right {@code num} chars and empty of the {@code num} is greater than the + * length of the CharSequence + * @since 3.0.0 + */ + public static String dropRight(GString self, int num) { + return dropRight(self.toString(), num); + } + + /** + * Returns the CharSequence that is in between the first occurrence of the given {@code from} and {@code to} + * CharSequences and empty if the unavailable inputs are given + * + * <pre class="groovyTestCase"> + * def text = "Groovy" + * + * assert text.takeBetween( 'r', 'v' ) == 'oo' + * assert text.takeBetween( 'r', 'z' ) == '' + * assert text.takeBetween( 'a', 'r' ) == '' + * + * </pre> + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @return the CharSequence that is in between the given two CharSequences and empty if the unavailable inputs are + * given + * @see #takeBetween(CharSequence, CharSequence, CharSequence, int) + * @since 3.0.0 + */ + public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to) { + if (from == null || to == null || from.length() == 0 || to.length() == 0 || from.length() > self.length() || to.length() > self.length()) + return self.subSequence(0, 0); + + String s = self.toString(); + String f = from.toString(); + + int fi = s.indexOf(f); + + if (fi == -1) + return self.subSequence(0, 0); + + String t = to.toString(); + + int ti = s.indexOf(t, fi + from.length()); + + if (ti == -1) + return self.subSequence(0, 0); + + return self.subSequence(fi + from.length(), ti); + } + + /** + * A String variant of the equivalent CharSequence method {@link #takeBetween(CharSequence, CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @return String that is in between the given two CharSequences and empty if the unavailable inputs are + * given + * @since 3.0.0 + */ + public static String takeBetween(String self, CharSequence from, CharSequence to) { + return (String) takeBetween((CharSequence) self, from, to); + } + + /** + * A GString variant of the equivalent CharSequence method {@link #takeBetween(CharSequence, CharSequence, CharSequence)} + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @return String that is in between the given two CharSequences and empty if the unavailable inputs are + * given + * @since 3.0.0 + */ + public static String takeBetween(GString self, CharSequence from, CharSequence to) { + return takeBetween(self.toString(), from, to); + } + + /** + * Method to take the characters between the first occurrence of the two subsequent {@code enclosure} strings + * + * <pre class="groovyTestCase"> + * def text = "name = 'some name'" + * + * assert text.takeBetween( "'" ) == 'some name' + * assert text.takeBetween( 'z' ) == '' + * + * </pre> + * + * @param self the original CharSequence + * @param enclosure Enclosure String + * @return CharSequence between the 2 subsequent {@code enclosure} strings + * @see #takeBetween(CharSequence, CharSequence, int) + * @since 3.0.0 + */ + public static CharSequence takeBetween(CharSequence self, CharSequence enclosure) { + return takeBetween(self, enclosure, enclosure); + } + + /** + * A String variant of the equivalent CharSequence method {@link #takeBetween(CharSequence, CharSequence)} + * + * @param self the original GString + * @param enclosure Enclosure String + * @return String between the 2 subsequent {@code enclosure} strings + * @since 3.0.0 + */ + public static String takeBetween(String self, CharSequence enclosure) { + return (String) takeBetween((CharSequence) self, enclosure); + } + + /** + * A GString variant of the equivalent CharSequence method {@link #takeBetween(CharSequence, CharSequence)} + * + * @param self the original GString + * @param enclosure Enclosure String + * @return String between the 2 subsequent {@code enclosure} strings + * @since 3.0.0 + */ + public static String takeBetween(GString self, CharSequence enclosure) { + return takeBetween(self.toString(), enclosure); + } + + /** + * Returns the CharSequence that is in between the given the nth (specified by occurrence) pair of + * {@code from} and {@code to} CharSequences and empty if the unavailable inputs are given. + * + * <pre class="groovyTestCase"> + * def text = "t1=10 ms, t2=100 ms" + * + * assert text.takeBetween( '=', ' ', 0 ) == '10' + * assert text.takeBetween( '=', ' ', 1 ) == '100' + * assert text.takeBetween( 't1', 'z' ) == '' + * </pre> + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @param occurrence nth occurrence that is to be returned. 0 represents first one + * @return the CharSequence that is in between the given the nth (specified by occurrence) pair of + * {@code from} and {@code to} CharSequences and empty if the unavailable inputs are given. + * @see #takeBetween(CharSequence, CharSequence, CharSequence) + * @since 3.0.0 + */ + public static CharSequence takeBetween(CharSequence self, CharSequence from, CharSequence to, int occurrence) { + if (from == null || to == null || from.length() > self.length() || to.length() > self.length() || (to.length() + from.length() >= self.length()) || occurrence < 0) + return self.subSequence(0, 0); + + String s = self.toString(); + String f = from.toString(); + + int start = 0; + int counter = 0; + + while (counter <= occurrence) { + int fi = s.indexOf(f, start); + + if (fi == -1) + return self.subSequence(0, 0); + + int ti = s.indexOf(to.toString(), fi + f.length()); + + if (ti == -1) + return self.subSequence(0, 0); + + if (counter == occurrence) + return self.subSequence(fi + f.length(), ti); + + start = ti + to.length() + 1; + counter++; + } + + return self.subSequence(0, 0); + } + + /** + * A String variant of the equivalent CharSequence method + * {@link #takeBetween(CharSequence, CharSequence, CharSequence, int)} + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @param occurrence nth occurrence that is to be returned. 0 represents first one + * @return the String that is in between the given nth (specified by occurrence) pair of + * {@code from} and {@code to} CharSequences and empty if the unavailable inputs are given. + * @since 3.0.0 + */ + public static String takeBetween(String self, CharSequence from, CharSequence to, int occurrence) { + return (String) takeBetween((CharSequence) self, from, to, occurrence); + } + + /** + * A GString variant of the equivalent CharSequence method + * {@link #takeBetween(CharSequence, CharSequence, CharSequence, int)} + * + * @param self the original CharSequence + * @param from beginning of search + * @param to end of search + * @param occurrence nth occurrence that is to be returned. 0 represents first one + * @return the String that is in between the given nth (specified by occurrence) pair of + * {@code from} and {@code to} CharSequences and empty if the unavailable inputs are given. + * @since 3.0.0 + */ + public static String takeBetween(GString self, CharSequence from, CharSequence to, int occurrence) { + return takeBetween(self.toString(), from, to, occurrence); + } + + /** + * Method to take the characters between nth (specified by occurrence) pair of @code enclosure} strings + * + * <pre class="groovyTestCase"> + * def text = "t1='10' ms, t2='100' ms" + * + * assert text.takeBetween( "'", 0 ) == '10' + * assert text.takeBetween( "'", 1 ) == '100' + * assert text.takeBetween( "'", 2 ) == '' + * </pre> + * + * @param self the original CharSequence + * @param enclosure Enclosure String + * @param occurrence nth occurrence being returned + * @return CharSequence between the nth occurrence of pair of {@code enclosure} strings + * @see #takeBetween(CharSequence, CharSequence, int) + * @since 3.0.0 + */ + public static CharSequence takeBetween(CharSequence self, CharSequence enclosure, int occurrence) { + return takeBetween(self, enclosure, enclosure, occurrence); + } + + /** + * A String variant of the equivalent CharSequence method + * {@link #takeBetween(CharSequence, CharSequence, int)} + * + * @param self the original CharSequence + * @param enclosure Enclosure String + * @param occurrence nth occurrence being returned + * @return String between the nth occurrence of pair of {@code enclosure} strings + * @since 3.0.0 + */ + public static String takeBetween(String self, CharSequence enclosure, int occurrence) { + return (String) takeBetween((CharSequence) self, enclosure, occurrence); + } + + /** + * A GString variant of the equivalent CharSequence method + * {@link #takeBetween(CharSequence, CharSequence, int)} + * + * @param self the original CharSequence + * @param enclosure Enclosure String + * @param occurrence nth occurrence being returned + * @return String between the nth occurrence of pair of {@code enclosure} strings + * @since 3.0.0 + */ + public static String takeBetween(GString self, CharSequence enclosure, int occurrence) { + return takeBetween(self.toString(), enclosure, occurrence); + } + + /** + * Checks whether this CharSequence starts with the {@code searchString} ignoring the case considerations + * + * @param self the original CharSequence + * @param searchString CharSequence being checked against this + * @return {@code true} if the character sequence represented by the argument is a prefix of this CharSequence + * ignoring the case considerations. {@code false} otherwise. Returns false if the argument is null + * @since 3.0.0 + */ + public static boolean startsWithIgnoreCase(CharSequence self, CharSequence searchString) { + if (searchString == null || searchString.length() == 0 || self.length() < searchString.length()) + return false; + + String s = take(self.toString(), searchString.length()).toString(); + + return s.equalsIgnoreCase(searchString.toString()); + } + + /** + * Checks whether this CharSequence ends with the {@code searchString} ignoring the case considerations + * + * @param self the original CharSequence + * @param searchString CharSequence bring checked against this + * @return {@code true} if the character sequence represented by the argument is a suffix of this CharSequence + * ignoring the case considerations. {@code false} otherwise. Returns false if the argument is null + * @since 3.0.0 + */ + public static boolean endsWithIgnoreCase(CharSequence self, CharSequence searchString) { + if (searchString == null || searchString.length() == 0 || self.length() < searchString.length()) + return false; + + String s = takeRight(self.toString(), searchString.length()).toString(); + + return s.equalsIgnoreCase(searchString.toString()); + } + + /** + * Checks whether this CharSequence contains the {@code searchString} ignoring the caseConsiderations + * + * @param self the original CharSequence + * @param searchString CharSequence being checked against this + * @return {@code true} if the character sequence represented by the argument exists in this CharSequence + * ignoring the case considerations. {@code false} otherwise. Returns false if the argument is null + * @since 3.0.0 + */ + public static boolean containsIgnoreCase(CharSequence self, CharSequence searchString) { + if (searchString == null || searchString.length() == 0 || self.length() < searchString.length()) + return false; + + return self.toString().toLowerCase().contains(searchString.toString().toLowerCase()); + } } diff --git a/src/test/groovy/GroovyMethodsTest.groovy b/src/test/groovy/GroovyMethodsTest.groovy index b773890a91..b23fd27723 100644 --- a/src/test/groovy/GroovyMethodsTest.groovy +++ b/src/test/groovy/GroovyMethodsTest.groovy @@ -19,6 +19,7 @@ package groovy import java.awt.Dimension +import java.nio.CharBuffer import java.util.concurrent.LinkedBlockingQueue import org.codehaus.groovy.util.StringUtil @@ -1820,6 +1821,339 @@ class GroovyMethodsTest extends GroovyTestCase { ([] as int[]).swap(1, 2) } } + + void testCharSequenceTakeRight() { + def data = ['groovy', // String + "${'groovy'}", // GString + java.nio.CharBuffer.wrap('groovy'), + new StringBuffer('groovy'), + new StringBuilder('groovy')] + data.each { + // Need toString() as CharBuffer.subSequence returns a java.nio.StringCharBuffer + assert it.takeRight(-1).toString() == '' + assert it.takeRight(0).toString() == '' + assert it.takeRight(3).toString() == 'ovy' + assert it.takeRight(6).toString() == 'groovy' + assert it.takeRight(10).toString() == 'groovy' + } + } + + void testCharSequenceTakeAfter() { + def text = 'Groovy development. Groovy team' + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + List<List<String>> searchStringsAndResults = [ + + ['Groovy', ' development. Groovy team'], + ['team', ''], + ['Java.', ''], + ['Unavailable text', ''], + ['Some larger String than self', ''], + ['', ''], + [null, ''] + ] + + data.each { s -> + + searchStringsAndResults.each { r -> + + // Need toString() as CharBuffer.subSequence returns a java.nio.StringCharBuffer + + assert s.takeAfter(r[0]).toString() == r[1] //String as searchString + assert s.takeAfter("${r[0]}").toString() == r[1] //GString as searchString + + if (r[0]) { + assert s.takeAfter(java.nio.CharBuffer.wrap(r[0])).toString() == r[1] //CharBuffer as searchString + assert s.takeAfter(new StringBuffer(r[0])).toString() == r[1] //StringBuffer as searchString + assert s.takeAfter(new StringBuilder(r[0])).toString() == r[1] //StringBuilder as searchString + } + } + } + + } + + void testCharSequenceTakeBefore() { + def text = "Groovy development. Groovy team" + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + List<List<String>> searchStringsAndResults = [ + + [' Groovy ', 'Groovy development.'], + ['Groovy', ''], + [' ', 'Groovy'], + ['Unavailable text', ''], + ['Some larger String than self', ''], + ['r', 'G'], + ['', ''], + [null, ''] + ] + + data.each { s -> + + searchStringsAndResults.each { r -> + + // Need toString() as CharBuffer.subSequence returns a java.nio.StringCharBuffer + + assert s.takeBefore(r[0]).toString() == r[1] //String as searchString + assert s.takeBefore("${r[0]}").toString() == r[1] //GString as searchString + + if (r[0]) { + assert s.takeBefore(java.nio.CharBuffer.wrap(r[0])).toString() == r[1] //CharBuffer as searchString + assert s.takeBefore(new StringBuffer(r[0])).toString() == r[1] //StringBuffer as searchString + assert s.takeBefore(new StringBuilder(r[0])).toString() == r[1] //StringBuilder as searchString + } + } + } + + } + + void testCharSequenceDropRight() { + def data = ['groovy', // String + "${'groovy'}", // GString + java.nio.CharBuffer.wrap('groovy'), + new StringBuffer('groovy'), + new StringBuilder('groovy')] + data.each { + // Need toString() as CharBuffer.subSequence returns a java.nio.StringCharBuffer + assert it.dropRight(-1).toString() == 'groovy' + assert it.dropRight(0).toString() == 'groovy' + assert it.dropRight(3).toString() == 'gro' + assert it.dropRight(6).toString() == '' + assert it.dropRight(10).toString() == '' + } + } + + void testCharSequenceTakeBetween() { + + def text = 'Time taken for Select Query = 12 ms, Update Query = 15 ms. Result = "One", "Two"' + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + data.each { s -> + + List<List<String>> fromToCasesWithoutNum = [ + + ['Query = ', ' ms', '12'], //positive case + ['Query = ', ' MS', ''], //negative case with invalid 'to' + ['Query123 = ', ' ms', ''] //negative case with invalid 'from' + ] + + fromToCasesWithoutNum.each { r -> + + assert s.takeBetween(r[0], r[1]).toString() == r[2] + assert s.takeBetween("${r[0]}", "${r[1]}").toString() == r[2] + + if (r[0] && r[1]) { + assert s.takeBetween(CharBuffer.wrap(r[0]), CharBuffer.wrap(r[1])).toString() == r[2] + assert s.takeBetween(new StringBuffer(r[0]), CharBuffer.wrap(r[1])).toString() == r[2] + assert s.takeBetween(CharBuffer.wrap(r[0]), new StringBuilder(r[1])).toString() == r[2] + } + } + } + + data.each { s -> + + List<List<String>> enclosureWithoutNum = [ + + ['"', 'One'], //positive case + ['Query', ' = 12 ms, Update '], //negative case with invalid enclosure + ['Query123', ''] //negative case with invalid enclosure + ] + + enclosureWithoutNum.each { r -> + + assert s.takeBetween(r[0]).toString() == r[1] + assert s.takeBetween("${r[0]}").toString() == r[1] + + if (r[0] && r[1]) { + assert s.takeBetween(CharBuffer.wrap(r[0])).toString() == r[1] + assert s.takeBetween(new StringBuffer(r[0])).toString() == r[1] + assert s.takeBetween(new StringBuilder(r[0])).toString() == r[1] + } + } + } + + data.each { s -> + + List<List<Object>> fromToCasesWithNum = [ + + ['Query = ', ' ms', 1, '15'], + ['Query = ', ' ms', 2, ''] + ] + + fromToCasesWithNum.each { r -> + + assert s.takeBetween(r[0], r[1], r[2]).toString() == r[3] + assert s.takeBetween("${r[0]}", "${r[1]}", r[2]).toString() == r[3] + + if (r[0] && r[1]) { + assert s.takeBetween(CharBuffer.wrap(r[0]), CharBuffer.wrap(r[1]), r[2]).toString() == r[3] + assert s.takeBetween(new StringBuffer(r[0]), new StringBuffer(r[1]), r[2]).toString() == r[3] + assert s.takeBetween(new StringBuilder(r[0]), new StringBuilder(r[1]), r[2]).toString() == r[3] + } + } + } + + data.each { s -> + + List<List<Object>> enclosureWithNum = [ + + ['"', 1, 'Two'], + ['"', 2, ''], + ['"', -1, ''] + ] + + enclosureWithNum.each { r -> + + assert s.takeBetween(r[0], r[1]).toString() == r[2] + assert s.takeBetween("${r[0]}", r[1]).toString() == r[2] + + if (r[0] && r[1]) { + assert s.takeBetween(CharBuffer.wrap(r[0]), r[1]).toString() == r[2] + assert s.takeBetween(new StringBuffer(r[0]), r[1]).toString() == r[2] + assert s.takeBetween(new StringBuilder(r[0]), r[1]).toString() == r[2] + } + } + } + + assert 'smalltext'.takeBetween('somelargertextfrom', 'somelargertextto') == '' + assert 'smalltext'.takeBetween('somelargertextfrom', 'somelargertextto', 0) == '' + + def text2 = "name = 'some name'" + + assert text2.takeBetween("'") == 'some name' + assert text2.takeBetween('z') == '' + + def text3 = "t1=10 ms, t2=100 ms" + + assert text3.takeBetween('=', ' ', 0) == '10' + assert text3.takeBetween('=', ' ', 1) == '100' + assert text3.takeBetween('t1', 'z') == '' + + assert 'one\ntwo\nthree'.takeBetween('\n') == 'two' + } + + void testCharSequenceStartsWithIgnoreCase() { + def text = 'Some Text' + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + List<List<Object>> searchStringsAndResults = [ + + ['SOME', true], + ['some', true], + ['Some', true], + ['Wrong', false], + ['Some larger String than self', false], + ['', false], + [null, false] + ] + + data.each { s -> + + searchStringsAndResults.each { r -> + + assert s.startsWithIgnoreCase(r[0]) == r[1] + assert s.startsWithIgnoreCase("${r[0]}") == r[1] + + if (r[0]) { + assert s.startsWithIgnoreCase(CharBuffer.wrap(r[0])) == r[1] + assert s.startsWithIgnoreCase(new StringBuffer(r[0])) == r[1] + assert s.startsWithIgnoreCase(new StringBuilder(r[0])) == r[1] + } + } + } + } + + void testCharSequenceEndsWithIgnoreCase() { + def text = 'Some Text' + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + List<List<Object>> searchStringsAndResults = [ + + ['TEXT', true], + ['text', true], + ['Text', true], + ['Wrong', false], + ['Some larger String than self', false], + ['', false], + [null, false] + ] + + data.each { s -> + + searchStringsAndResults.each { r -> + + assert s.endsWithIgnoreCase(r[0]) == r[1] + assert s.endsWithIgnoreCase("${r[0]}") == r[1] + + if (r[0]) { + assert s.endsWithIgnoreCase(CharBuffer.wrap(r[0])) == r[1] + assert s.endsWithIgnoreCase(new StringBuffer(r[0])) == r[1] + assert s.endsWithIgnoreCase(new StringBuilder(r[0])) == r[1] + } + } + } + } + + void testCharSequenceContainsIgnoreCase() { + def text = 'Some Text' + + def data = [text, // String + "${text}", // GString + java.nio.CharBuffer.wrap(text), + new StringBuffer(text), + new StringBuilder(text)] + + List<List<Object>> searchStringsAndResults = [ + + ['E TEX', true], + ['Me t', true], + ['me T', true], + ['Wrong', false], + ['Some larger String than self', false], + ['', false], + [null, false] + ] + + data.each { s -> + + searchStringsAndResults.each { r -> + + assert s.containsIgnoreCase(r[0]) == r[1] + assert s.containsIgnoreCase("${r[0]}") == r[1] + + if (r[0]) { + assert s.containsIgnoreCase(CharBuffer.wrap(r[0])) == r[1] + assert s.containsIgnoreCase(new StringBuffer(r[0])) == r[1] + assert s.containsIgnoreCase(new StringBuilder(r[0])) == r[1] + } + } + } + } } class WackyList extends LinkedList { ---------------------------------------------------------------- This is an automated message from the Apache Git Service. To respond to the message, please log on GitHub and use the URL above to go to the specific comment. For queries about this service, please contact Infrastructure at: us...@infra.apache.org With regards, Apache Git Services