> On 27 Dec 2016, at 08:45, djo...@apache.org wrote: > > Repository: commons-text > Updated Branches: > refs/heads/master 6f6da3467 -> 08ac56a50 > > > Rename RandomStringBuilder and make it immutable and thread-safe. > > The RandomStringBuilder class was renamed to RandomStringGenerator. The > class is now constructed using an inner Builder class, resulting in an > immutable and thread-safe generator. The default random generator is now > ThreadLocalRandom rather than Random. > > The inner CodePointPredicate class was extracted into a separate class > and renamed to CharacterPredicate. The commonly used predicates are now > in a separate enum, CharacterPredicates. > > Project: http://git-wip-us.apache.org/repos/asf/commons-text/repo > Commit: http://git-wip-us.apache.org/repos/asf/commons-text/commit/08ac56a5 > Tree: http://git-wip-us.apache.org/repos/asf/commons-text/tree/08ac56a5 > Diff: http://git-wip-us.apache.org/repos/asf/commons-text/diff/08ac56a5 > > Branch: refs/heads/master > Commit: 08ac56a502adb0d274d02f9d97f394e4a5c5966e > Parents: 6f6da34 > Author: duncan <dun...@wortharead.com> > Authored: Tue Dec 27 08:18:52 2016 +0000 > Committer: duncan <dun...@wortharead.com> > Committed: Tue Dec 27 08:42:48 2016 +0000 > > ---------------------------------------------------------------------- > .../apache/commons/text/CharacterPredicate.java | 37 ++ > .../commons/text/CharacterPredicates.java | 52 +++ > .../commons/text/RandomStringBuilder.java | 354 ------------------- > .../commons/text/RandomStringGenerator.java | 316 +++++++++++++++++ > .../commons/text/CharacterPredicatesTest.java | 50 +++ > .../commons/text/RandomStringBuilderTest.java | 235 ------------ > .../commons/text/RandomStringGeneratorTest.java | 206 +++++++++++ > 7 files changed, 661 insertions(+), 589 deletions(-) > ———————————————————————————————————
Apologies, should have split this into multiple commits but I got too far into it before I reached that conclusion! > > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/main/java/org/apache/commons/text/CharacterPredicate.java > ---------------------------------------------------------------------- > diff --git a/src/main/java/org/apache/commons/text/CharacterPredicate.java > b/src/main/java/org/apache/commons/text/CharacterPredicate.java > new file mode 100644 > index 0000000..fb23ac4 > --- /dev/null > +++ b/src/main/java/org/apache/commons/text/CharacterPredicate.java > @@ -0,0 +1,37 @@ > +/* > + * 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.text; > + > +/** > + * A predicate for selecting code points. Implementations of this interface > must > + * be thread safe. > + * > + * @since 1.0 > + */ > +public interface CharacterPredicate { > + > + /** > + * Tests the code point with this predicate. > + * > + * @param codePoint > + * the code point to test > + * @return {@code true} if the code point matches the predicate, > + * {@code false} otherwise > + * @since 1.0 > + */ > + boolean test(int codePoint); > +} > \ No newline at end of file > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/main/java/org/apache/commons/text/CharacterPredicates.java > ---------------------------------------------------------------------- > diff --git a/src/main/java/org/apache/commons/text/CharacterPredicates.java > b/src/main/java/org/apache/commons/text/CharacterPredicates.java > new file mode 100644 > index 0000000..7f38552 > --- /dev/null > +++ b/src/main/java/org/apache/commons/text/CharacterPredicates.java > @@ -0,0 +1,52 @@ > +/* > + * 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.text; > + > +/** > + * <p> > + * Commonly used implementations of {@link CharacterPredicate}. Per the > interface > + * requirements, all implementations are thread safe. > + * </p> > + * > + * @since 1.0 > + */ > +public enum CharacterPredicates implements CharacterPredicate { > + > + /** > + * Tests code points against {@link Character#isLetter(int)} > + * > + * @since 1.0 > + */ > + LETTERS { > + @Override > + public boolean test(int codePoint) { > + return Character.isLetter(codePoint); > + } > + }, > + > + /** > + * Tests code points against {@link Character#isDigit(int)}. > + * > + * @since 1.0 > + */ > + DIGITS { > + @Override > + public boolean test(int codePoint) { > + return Character.isDigit(codePoint); > + } > + } > +} > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/main/java/org/apache/commons/text/RandomStringBuilder.java > ---------------------------------------------------------------------- > diff --git a/src/main/java/org/apache/commons/text/RandomStringBuilder.java > b/src/main/java/org/apache/commons/text/RandomStringBuilder.java > deleted file mode 100644 > index 38ba974..0000000 > --- a/src/main/java/org/apache/commons/text/RandomStringBuilder.java > +++ /dev/null > @@ -1,354 +0,0 @@ > -/* > - * Licensed to the Apache Software Foundation (ASF) under one or more > - * contributor license agreements. See the NOTICE file distributed with > - * this work for additional information regarding copyright ownership. > - * The ASF licenses this file to You under the Apache License, Version 2.0 > - * (the "License"); you may not use this file except in compliance with > - * the License. You may obtain a copy of the License at > - * > - * http://www.apache.org/licenses/LICENSE-2.0 > - * > - * Unless required by applicable law or agreed to in writing, software > - * distributed under the License is distributed on an "AS IS" BASIS, > - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > - * See the License for the specific language governing permissions and > - * limitations under the License. > - */ > -package org.apache.commons.text; > - > -import java.util.HashSet; > -import java.util.Random; > -import java.util.Set; > - > -/** > - * <p> > - * Generates a random Unicode string based on properties defined using a > builder > - * pattern. > - * </p> > - * <p> > - * Overriding the default properties is optional, however callers will need > to > - * define the length of the output string using {@link #ofLength(int)} to > avoid > - * generating an empty string. > - * </p> > - * <p> > - * All the property setting methods return the {@code RandomStringBuilder} > - * instance to allow for method chaining: > - * </p> > - * > - * <pre> > - * // Generates a 20 code point string, using only the letters a-z > - * String random = new > RandomStringBuilder().ofLength(20).withinRange('a','z').build(); > - * </pre> > - * > - * <p> > - * The type of code point returned can be filtered using > - * {@link #filteredBy(CodePointPredicate...)}, which defines a collection of > - * tests that are applied to the randomly generated code points. The code > points > - * will only be included in the result if they pass at least one of the > tests. > - * Some commonly used predicates are provided (e.g. {@link #LETTERS} or > - * {@link #DIGITS}) and others can be created by implementing > - * {@link CodePointPredicate}. > - * </p> > - * > - * <pre> > - * // Generates a 10 code point string containing only letters > - * > - * import static org.apache.commons.text.RandomStringBuilder.LETTERS; > - * ... > - * String random = new > RandomStringBuilder().ofLength(10).filteredBy(LETTERS).build(); > - * </pre> > - * > - * <p> > - * A {@code RandomStringBuilder} instance can be used multiple times to > generate > - * different random strings, however it cannot safely be shared between > threads. > - * </p> > - * > - * @since 1.0 > - */ > -public class RandomStringBuilder implements Builder<String> { > - > - /** > - * Default source of randomness > - */ > - private static final Random DEFAULT_RANDOM = new Random(); > - > - /** > - * The default string length produced by this builder: {@value} > - * > - * @since 1.0 > - */ > - public static final int DEFAULT_LENGTH = 0; > - > - /** > - * The default minimum code point allowed: {@value} > - * > - * @since 1.0 > - */ > - public static final int DEFAULT_MINIMUM_CODE_POINT = 0; > - > - /** > - * The default maximum code point allowed: {@link > Character#MAX_CODE_POINT} > - * ({@value}) > - * > - * @since 1.0 > - */ > - public static final int DEFAULT_MAXIMUM_CODE_POINT = > Character.MAX_CODE_POINT; > - > - private int length = 0; > - private int minimumCodePoint = 0; > - private int maximumCodePoint = Character.MAX_CODE_POINT; > - private Set<CodePointPredicate> inclusivePredicates = null; > - private Random random = null; > - > - /** > - * <p> > - * Constructs a builder with default properties: > - * </p> > - * > - * <ul> > - * <li>Length: {@value #DEFAULT_LENGTH}</li> > - * <li>Minimum code point: {@value #DEFAULT_MINIMUM_CODE_POINT}</li> > - * <li>Maximum code point: {@link Character#MAX_CODE_POINT}</li> > - * <li>Default source of randomness</li> > - * <li>No character filters</li> > - * </ul> > - * > - * @since 1.0 > - */ > - public RandomStringBuilder() { > - } > - > - /** > - * <p> > - * Specifies how many code points to generate in the random string. > - * </p> > - * <p> > - * Note: the number of {@code char} code units generated will exceed > - * {@code length} if the string contains supplementary characters. See > the > - * {@link Character} documentation to understand how Java stores Unicode > - * values. > - * </p> > - * > - * @param length > - * the number of code points to generate > - * @return {@code this}, to allow method chaining > - * @throws IllegalArgumentException > - * if {@code length < 0} > - * @since 1.0 > - */ > - public RandomStringBuilder ofLength(final int length) { > - if (length < 0) { > - throw new IllegalArgumentException(String.format("Length %d is > smaller than zero.", length)); > - } > - > - this.length = length; > - return this; > - } > - > - /** > - * <p> > - * Specifies the minimum and maximum code points allowed in the generated > - * string. > - * </p> > - * > - * @param minimumCodePoint > - * the smallest code point allowed (inclusive) > - * @param maximumCodePoint > - * the largest code point allowed (inclusive) > - * @return {@code this}, to allow method chaining > - * @throws IllegalArgumentException > - * if {@code maximumCodePoint >} > - * {@link Character#MAX_CODE_POINT} > - * @throws IllegalArgumentException > - * if {@code minimumCodePoint < 0} > - * @throws IllegalArgumentException > - * if {@code minimumCodePoint > maximumCodePoint} > - * @since 1.0 > - */ > - public RandomStringBuilder withinRange(final int minimumCodePoint, final > int maximumCodePoint) { > - if (minimumCodePoint > maximumCodePoint) { > - throw new IllegalArgumentException(String.format( > - "Minimum code point %d is larger than maximum code point > %d", minimumCodePoint, maximumCodePoint)); > - } > - if (minimumCodePoint < 0) { > - throw new IllegalArgumentException(String.format("Minimum code > point %d is negative", minimumCodePoint)); > - } > - if (maximumCodePoint > Character.MAX_CODE_POINT) { > - throw new IllegalArgumentException( > - String.format("Value %d is larger than > Character.MAX_CODE_POINT.", maximumCodePoint)); > - } > - > - this.minimumCodePoint = minimumCodePoint; > - this.maximumCodePoint = maximumCodePoint; > - return this; > - } > - > - /** > - * <p> > - * Overrides the default source of randomness. > - * </p> > - * > - * <p> > - * Passing {@code null} to this method will revert to the default source > of > - * randomness. > - * </p> > - * > - * @param random > - * the source of randomness, may be {@code null} > - * @return {@code this}, to allow method chaining > - * @since 1.0 > - */ > - public RandomStringBuilder usingRandom(final Random random) { > - this.random = random; > - return this; > - } > - > - /** > - * <p> > - * Limits the characters in the generated string to those that match at > - * least one of the predicates supplied. > - * </p> > - * > - * <p> > - * Passing {@code null} or an empty array to this method will revert to > the > - * default behaviour of allowing any character. Multiple calls to this > - * method will replace the previously stored predicates. > - * </p> > - * > - * @param predicates > - * the predicates, may be {@code null} or empty > - * @return {@code this}, to allow method chaining > - * @since 1.0 > - */ > - public RandomStringBuilder filteredBy(final CodePointPredicate... > predicates) { > - if (predicates == null || predicates.length == 0) { > - inclusivePredicates = null; > - return this; > - } > - > - if (inclusivePredicates == null) { > - inclusivePredicates = new HashSet<>(); > - } else { > - inclusivePredicates.clear(); > - } > - > - for (CodePointPredicate predicate : predicates) { > - inclusivePredicates.add(predicate); > - } > - > - return this; > - } > - > - /** > - * <p> > - * Generates a random string using the settings defined in this builder. > - * Code points are randomly selected between the minimum and maximum > values. > - * Surrogate and private use characters are not returned, although the > - * resulting string may contain pairs of surrogates that together encode > a > - * supplementary character. > - * </p> > - * > - * <p> > - * A static {@code Random} instance is used if an alternative wasn't > - * provided via {@link #usingRandom(Random)}. > - * </p> > - * > - * @return the randomly generated string > - * @since 1.0 > - */ > - @Override > - public String build() { > - if (length == 0) { > - return ""; > - } > - > - if (random == null) { > - random = DEFAULT_RANDOM; > - } > - > - final StringBuilder builder = new StringBuilder(length); > - long remaining = length; > - > - do { > - int codePoint = random.nextInt(maximumCodePoint - > minimumCodePoint + 1) + minimumCodePoint; > - > - switch (Character.getType(codePoint)) { > - case Character.UNASSIGNED: > - case Character.PRIVATE_USE: > - case Character.SURROGATE: > - continue; > - } > - > - if (inclusivePredicates != null) { > - boolean matchedFilter = false; > - for (CodePointPredicate predicate : inclusivePredicates) { > - if (predicate.test(codePoint)) { > - matchedFilter = true; > - break; > - } > - } > - if (!matchedFilter) { > - continue; > - } > - } > - > - builder.appendCodePoint(codePoint); > - remaining--; > - > - } while (remaining != 0); > - > - return builder.toString(); > - } > - > - /** > - * A predicate for selecting code points. > - * > - * @since 1.0 > - */ > - public static interface CodePointPredicate { > - /** > - * Tests the code point with this predicate. > - * > - * @param codePoint > - * the code point to test > - * @return {@code true} if the code point matches the predicate, > - * {@code false} otherwise > - * @since 1.0 > - */ > - boolean test(int codePoint); > - } > - > - /** > - * Tests code points against {@link Character#isLetter(int)}. > - * > - * @since 1.0 > - */ > - public static final CodePointPredicate LETTERS = new LetterPredicate(); > - > - /** > - * Tests code points against {@link Character#isDigit(int)}. > - * > - * @since 1.0 > - */ > - public static final CodePointPredicate DIGITS = new DigitPredicate(); > - > - /** > - * Tests whether code points are letters. > - */ > - private static final class LetterPredicate implements CodePointPredicate > { > - @Override > - public boolean test(int codePoint) { > - return Character.isLetter(codePoint); > - } > - } > - > - /** > - * Tests whether code points are digits. > - */ > - private static final class DigitPredicate implements CodePointPredicate { > - @Override > - public boolean test(int codePoint) { > - return Character.isDigit(codePoint); > - } > - }; > -} > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/main/java/org/apache/commons/text/RandomStringGenerator.java > ---------------------------------------------------------------------- > diff --git a/src/main/java/org/apache/commons/text/RandomStringGenerator.java > b/src/main/java/org/apache/commons/text/RandomStringGenerator.java > new file mode 100644 > index 0000000..c4411a2 > --- /dev/null > +++ b/src/main/java/org/apache/commons/text/RandomStringGenerator.java > @@ -0,0 +1,316 @@ > +/* > + * 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.text; > + > +import java.util.HashSet; > +import java.util.Random; > +import java.util.Set; > +import java.util.concurrent.ThreadLocalRandom; > + > +/** > + * <p> > + * Generates random Unicode strings containing the specified number of code > points. > + * Instances are created using a builder class, which allows the > + * callers to define the properties of the generator. See the documentation > for the > + * {@link Builder} class to see available properties. > + * </p> > + * > + * <pre> > + * // Generates a 20 code point string, using only the letters a-z > + * RandomStringGenerator generator = new > RandomStringGenerator.Builder().withinRange('a', 'z').build(); > + * String random = generator.generate(20); > + * </pre> > + * > + * <p> > + * {@code RandomStringBuilder} instances are immutable and thread-safe. > + * </p> > + * > + * @since 1.0 > + */ > +public final class RandomStringGenerator { > + > + private final int minimumCodePoint; > + private final int maximumCodePoint; > + private final Set<CharacterPredicate> inclusivePredicates; > + private final Random random; > + > + > + /** > + * Constructs the generator. > + * > + * @param minimumCodePoint > + * smallest allowed code point (inclusive) > + * @param maximumCodePoint > + * largest allowed code point (inclusive) > + * @param inclusivePredicates > + * filters for code points > + * @param random > + * source of randomness > + */ > + private RandomStringGenerator(int minimumCodePoint, int maximumCodePoint, > + Set<CharacterPredicate> inclusivePredicates, Random random) { > + this.minimumCodePoint = minimumCodePoint; > + this.maximumCodePoint = maximumCodePoint; > + this.inclusivePredicates = inclusivePredicates; > + this.random = random; > + } > + > + /** > + * Generates a random number within a range, using a > + * {@link ThreadLocalRandom} instance or the user-supplied source of > + * randomness. > + * > + * @param minInclusive > + * the minimum value allowed > + * @param maxInclusive > + * the maximum value allowed > + * @return the random number. > + */ > + private int generateRandomNumber(final int minInclusive, final int > maxInclusive) { > + if (random != null) { > + return random.nextInt(maxInclusive - minInclusive + 1) + > minInclusive; > + } > + > + return ThreadLocalRandom.current().nextInt(minInclusive, > maxInclusive + 1); > + } > + > + > + /** > + * <p> > + * Generates a random string, containing the specified number of code > points. > + * </p> > + * <p>Code points are randomly selected between the minimum and maximum > values defined > + * in the generator. > + * Surrogate and private use characters are not returned, although the > + * resulting string may contain pairs of surrogates that together encode > a > + * supplementary character. > + * </p> > + * <p> > + * Note: the number of {@code char} code units generated will exceed > + * {@code length} if the string contains supplementary characters. See > the > + * {@link Character} documentation to understand how Java stores Unicode > + * values. > + * </p> > + * > + * @param length > + * the number of code points to generate > + * @return the generated string > + * @throws IllegalArgumentException > + * if {@code length < 0} > + * @since 1.0 > + */ > + public String generate(final int length) { > + if (length == 0) { > + return ""; > + } > + > + if (length < 0) { > + throw new IllegalArgumentException(String.format("Length %d is > smaller than zero.", length)); > + } > + > + final StringBuilder builder = new StringBuilder(length); > + long remaining = length; > + > + do { > + int codePoint = generateRandomNumber(minimumCodePoint, > maximumCodePoint); > + > + switch (Character.getType(codePoint)) { > + case Character.UNASSIGNED: > + case Character.PRIVATE_USE: > + case Character.SURROGATE: > + continue; > + } > + > + if (inclusivePredicates != null) { > + boolean matchedFilter = false; > + for (CharacterPredicate predicate : inclusivePredicates) { > + if (predicate.test(codePoint)) { > + matchedFilter = true; > + break; > + } > + } > + if (!matchedFilter) { > + continue; > + } > + } > + > + builder.appendCodePoint(codePoint); > + remaining--; > + > + } while (remaining != 0); > + > + return builder.toString(); > + } > + > + > + /** > + * <p>A builder for generating {@code RandomStringGenerator} > instances.</p> > + * <p>The behaviour of a generator is controlled by properties set by > this > + * builder. Each property has a default value, which can be overridden by > + * calling the methods defined in this class, prior to calling {@link > #build()}.</p> > + * > + * <p>All the property setting methods return the {@code Builder} > instance to allow for method chaining.</p> > + * > + * <p>The minimum and maximum code point values are defined using {@link > #withinRange(int, int)}. The > + * default values are {@code 0} and {@link Character#MAX_CODE_POINT} > respectively.</p> > + * > + * <p>The source of randomness can be set using {@link > #usingRandom(Random)}, otherwise {@link ThreadLocalRandom} > + * is used.</p> > + * > + * <p>The type of code points returned can be filtered using {@link > #filteredBy(CharacterPredicate...)}, > + * which defines a collection of > + * tests that are applied to the randomly generated code points. The > code points > + * will only be included in the result if they pass at least one of the > tests. > + * Some commonly used predicates are provided by the {@link > CharacterPredicates} enum.</p> > + * > + * <p>This class is not thread safe.</p> > + * @since 1.0 > + */ > + public static class Builder implements > org.apache.commons.text.Builder<RandomStringGenerator> { > + > + /** > + * The default maximum code point allowed: {@link > Character#MAX_CODE_POINT} > + * ({@value}) > + * > + * @since 1.0 > + */ > + public static final int DEFAULT_MAXIMUM_CODE_POINT = > Character.MAX_CODE_POINT; > + > + /** > + * The default string length produced by this builder: {@value} > + * > + * @since 1.0 > + */ > + public static final int DEFAULT_LENGTH = 0; > + > + /** > + * The default minimum code point allowed: {@value} > + * > + * @since 1.0 > + */ > + public static final int DEFAULT_MINIMUM_CODE_POINT = 0; > + > + private int minimumCodePoint = DEFAULT_MINIMUM_CODE_POINT; > + private int maximumCodePoint = DEFAULT_MAXIMUM_CODE_POINT; > + private Set<CharacterPredicate> inclusivePredicates; > + private Random random; > + > + > + /** > + * <p> > + * Specifies the minimum and maximum code points allowed in the > generated > + * string. > + * </p> > + * > + * @param minimumCodePoint > + * the smallest code point allowed (inclusive) > + * @param maximumCodePoint > + * the largest code point allowed (inclusive) > + * @return {@code this}, to allow method chaining > + * @throws IllegalArgumentException > + * if {@code maximumCodePoint >} > + * {@link Character#MAX_CODE_POINT} > + * @throws IllegalArgumentException > + * if {@code minimumCodePoint < 0} > + * @throws IllegalArgumentException > + * if {@code minimumCodePoint > maximumCodePoint} > + * @since 1.0 > + */ > + public Builder withinRange(final int minimumCodePoint, final int > maximumCodePoint) { > + if (minimumCodePoint > maximumCodePoint) { > + throw new IllegalArgumentException(String.format( > + "Minimum code point %d is larger than maximum code > point %d", minimumCodePoint, maximumCodePoint)); > + } > + if (minimumCodePoint < 0) { > + throw new IllegalArgumentException(String.format("Minimum > code point %d is negative", minimumCodePoint)); > + } > + if (maximumCodePoint > Character.MAX_CODE_POINT) { > + throw new IllegalArgumentException( > + String.format("Value %d is larger than > Character.MAX_CODE_POINT.", maximumCodePoint)); > + } > + > + this.minimumCodePoint = minimumCodePoint; > + this.maximumCodePoint = maximumCodePoint; > + return this; > + } > + > + /** > + * <p> > + * Limits the characters in the generated string to those that match > at > + * least one of the predicates supplied. > + * </p> > + * > + * <p> > + * Passing {@code null} or an empty array to this method will revert > to the > + * default behaviour of allowing any character. Multiple calls to > this > + * method will replace the previously stored predicates. > + * </p> > + * > + * @param predicates > + * the predicates, may be {@code null} or empty > + * @return {@code this}, to allow method chaining > + * @since 1.0 > + */ > + public Builder filteredBy(final CharacterPredicate... predicates) { > + if (predicates == null || predicates.length == 0) { > + inclusivePredicates = null; > + return this; > + } > + > + if (inclusivePredicates == null) { > + inclusivePredicates = new HashSet<>(); > + } else { > + inclusivePredicates.clear(); > + } > + > + for (CharacterPredicate predicate : predicates) { > + inclusivePredicates.add(predicate); > + } > + > + return this; > + } > + > + /** > + * <p> > + * Overrides the default source of randomness. > + * </p> > + * > + * <p> > + * Passing {@code null} to this method will revert to the default > source of > + * randomness. > + * </p> > + * > + * @param random > + * the source of randomness, may be {@code null} > + * @return {@code this}, to allow method chaining > + * @since 1.0 > + */ > + public Builder usingRandom(final Random random) { > + this.random = random; > + return this; > + } > + > + /** > + * <p>Builds the {@code RandomStringGenerator} using the properties > specified.</p> > + */ > + @Override > + public RandomStringGenerator build() { > + return new RandomStringGenerator(minimumCodePoint, > maximumCodePoint, inclusivePredicates, random); > + } > + > + } > +} > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java > ---------------------------------------------------------------------- > diff --git > a/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java > b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java > new file mode 100644 > index 0000000..3ff8b74 > --- /dev/null > +++ b/src/test/java/org/apache/commons/text/CharacterPredicatesTest.java > @@ -0,0 +1,50 @@ > +/* > + * 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.text; > + > +import static org.junit.Assert.assertTrue; > + > +import org.junit.Test; > + > +/** > + * Tests for implementations in the {@link CharacterPredicates} enum. > + */ > +public class CharacterPredicatesTest { > + @Test > + public void testDigitPredicate() throws Exception { > + String str = new > RandomStringGenerator.Builder().filteredBy(CharacterPredicates.DIGITS).build().generate(5000); > + > + int i = 0; > + do { > + int codePoint = str.codePointAt(i); > + assertTrue(Character.isDigit(codePoint)); > + i += Character.charCount(codePoint); > + } while (i < str.length()); > + } > + > + @Test > + public void testLetterPredicate() throws Exception { > + String str = new > RandomStringGenerator.Builder().filteredBy(CharacterPredicates.LETTERS).build().generate(5000); > + > + int i = 0; > + do { > + int codePoint = str.codePointAt(i); > + assertTrue(Character.isLetter(codePoint)); > + i += Character.charCount(codePoint); > + } while (i < str.length()); > + } > +} > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/test/java/org/apache/commons/text/RandomStringBuilderTest.java > ---------------------------------------------------------------------- > diff --git > a/src/test/java/org/apache/commons/text/RandomStringBuilderTest.java > b/src/test/java/org/apache/commons/text/RandomStringBuilderTest.java > deleted file mode 100644 > index e6f9f81..0000000 > --- a/src/test/java/org/apache/commons/text/RandomStringBuilderTest.java > +++ /dev/null > @@ -1,235 +0,0 @@ > -/* > - * Licensed to the Apache Software Foundation (ASF) under one or more > - * contributor license agreements. See the NOTICE file distributed with > - * this work for additional information regarding copyright ownership. > - * The ASF licenses this file to You under the Apache License, Version 2.0 > - * (the "License"); you may not use this file except in compliance with > - * the License. You may obtain a copy of the License at > - * > - * http://www.apache.org/licenses/LICENSE-2.0 > - * > - * Unless required by applicable law or agreed to in writing, software > - * distributed under the License is distributed on an "AS IS" BASIS, > - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > - * See the License for the specific language governing permissions and > - * limitations under the License. > - */ > -package org.apache.commons.text; > - > -import static org.apache.commons.text.RandomStringBuilder.LETTERS; > -import static org.junit.Assert.*; > - > -import java.util.Random; > - > -import org.apache.commons.text.RandomStringBuilder.CodePointPredicate; > -import org.junit.Test; > - > -/** > - * Tests for {@link RandomStringBuilder} > - */ > -public class RandomStringBuilderTest { > - > - private static int codePointLength(String s) { > - return s.codePointCount(0, s.length()); > - } > - > - private static final CodePointPredicate A_FILTER = new > CodePointPredicate() { > - @Override > - public boolean test(int codePoint) { > - return codePoint == 'a'; > - } > - }; > - > - private static final CodePointPredicate B_FILTER = new > CodePointPredicate() { > - @Override > - public boolean test(int codePoint) { > - return codePoint == 'b'; > - } > - }; > - > - @Test > - public void testDefaultLength() throws Exception { > - String str = new RandomStringBuilder().build(); > - assertEquals(RandomStringBuilder.DEFAULT_LENGTH, > codePointLength(str)); > - } > - > - @Test(expected = IllegalArgumentException.class) > - public void testInvalidLength() throws Exception { > - new RandomStringBuilder().ofLength(-1); > - } > - > - @Test > - public void testSetLength() throws Exception { > - final int length = 99; > - String str = new RandomStringBuilder().ofLength(length).build(); > - assertEquals(length, codePointLength(str)); > - } > - > - @Test(expected = IllegalArgumentException.class) > - public void testBadMinimumCodePoint() throws Exception { > - new RandomStringBuilder().withinRange(-1, 1); > - } > - > - @Test(expected = IllegalArgumentException.class) > - public void testBadMaximumCodePoint() throws Exception { > - new RandomStringBuilder().withinRange(0, Character.MAX_CODE_POINT + > 1); > - } > - > - @Test > - public void testWithinRange() throws Exception { > - final int length = 5000; > - final int minimumCodePoint = 'a'; > - final int maximumCodePoint = 'z'; > - String str = new > RandomStringBuilder().ofLength(length).withinRange(minimumCodePoint,maximumCodePoint).build(); > - > - int i = 0; > - do { > - int codePoint = str.codePointAt(i); > - assertTrue(codePoint >= minimumCodePoint && codePoint <= > maximumCodePoint); > - i += Character.charCount(codePoint); > - } while (i < str.length()); > - > - } > - > - @Test > - public void testNoLoneSurrogates() throws Exception { > - final int length = 5000; > - String str = new RandomStringBuilder().ofLength(length).build(); > - > - char lastChar = str.charAt(0); > - for (int i = 1; i < str.length(); i++) { > - char c = str.charAt(i); > - > - if (Character.isLowSurrogate(c)) { > - assertTrue(Character.isHighSurrogate(lastChar)); > - } > - > - if (Character.isHighSurrogate(lastChar)) { > - assertTrue(Character.isLowSurrogate(c)); > - } > - > - if (Character.isHighSurrogate(c)) { > - // test this isn't the last character in the string > - assertTrue(i + 1 < str.length()); > - } > - > - lastChar = c; > - } > - } > - > - @Test > - public void testUsingRandom() throws Exception { > - final char testChar = 'a'; > - final Random testRandom = new Random() { > - private static final long serialVersionUID = 1L; > - > - @Override > - public int nextInt(int n) { > - return testChar; > - } > - }; > - > - String str = new > RandomStringBuilder().ofLength(100).usingRandom(testRandom).build(); > - for (char c : str.toCharArray()) { > - assertEquals(testChar, c); > - } > - } > - > - @Test > - public void testLetterPredicate() throws Exception { > - String str = new > RandomStringBuilder().ofLength(5000).filteredBy(LETTERS).build(); > - > - int i = 0; > - do { > - int codePoint = str.codePointAt(i); > - assertTrue(Character.isLetter(codePoint)); > - i += Character.charCount(codePoint); > - } while (i < str.length()); > - } > - > - @Test > - public void testDigitPredicate() throws Exception { > - String str = new > RandomStringBuilder().ofLength(5000).filteredBy(RandomStringBuilder.DIGITS).build(); > - > - int i = 0; > - do { > - int codePoint = str.codePointAt(i); > - assertTrue(Character.isDigit(codePoint)); > - i += Character.charCount(codePoint); > - } while (i < str.length()); > - } > - > - @Test > - public void testMultipleFilters() throws Exception { > - String str = new > RandomStringBuilder().ofLength(5000).withinRange('a','d') > - .filteredBy(A_FILTER, B_FILTER).build(); > - > - boolean aFound = false; > - boolean bFound = false; > - > - for (char c : str.toCharArray()) { > - if (c == 'a') { > - aFound = true; > - } else if (c == 'b') { > - bFound = true; > - } else { > - fail("Invalid character"); > - } > - } > - > - assertTrue(aFound && bFound); > - } > - > - @Test > - public void testNoPrivateCharacters() throws Exception { > - final int startOfPrivateBMPChars = 0xE000; > - > - // Request a string in an area of the Basic Multilingual Plane that > is > - // largely > - // occupied by private characters > - String str = new > RandomStringBuilder().ofLength(5000).withinRange(startOfPrivateBMPChars, > - Character.MIN_SUPPLEMENTARY_CODE_POINT - 1).build(); > - > - int i = 0; > - do { > - int codePoint = str.codePointAt(i); > - assertFalse(Character.getType(codePoint) == > Character.PRIVATE_USE); > - i += Character.charCount(codePoint); > - } while (i < str.length()); > - } > - > - @Test(expected = IllegalArgumentException.class) > - public void testBadMinAndMax() throws Exception { > - new RandomStringBuilder().withinRange(2, 1); > - } > - > - @Test > - public void testRemoveFilters() throws Exception { > - > - RandomStringBuilder builder = new > RandomStringBuilder().ofLength(100).withinRange('a', 'z') > - .filteredBy(A_FILTER); > - > - builder.filteredBy(); > - > - String str = builder.build(); > - for (char c : str.toCharArray()) { > - if (c != 'a') { > - // filter was successfully removed > - return; > - } > - } > - > - fail("Filter appears to have remained in place"); > - } > - > - @Test > - public void testChangeOfFilter() throws Exception { > - RandomStringBuilder builder = new > RandomStringBuilder().ofLength(100).withinRange('a', 'z') > - .filteredBy(A_FILTER); > - String str = builder.filteredBy(B_FILTER).build(); > - > - for (char c : str.toCharArray()) { > - assertTrue(c == 'b'); > - } > - } > -} > > http://git-wip-us.apache.org/repos/asf/commons-text/blob/08ac56a5/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java > ---------------------------------------------------------------------- > diff --git > a/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java > b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java > new file mode 100644 > index 0000000..2ff7a67 > --- /dev/null > +++ b/src/test/java/org/apache/commons/text/RandomStringGeneratorTest.java > @@ -0,0 +1,206 @@ > +/* > + * 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.text; > + > +import static org.junit.Assert.*; > + > +import java.util.Random; > + > +import org.junit.Test; > + > +/** > + * Tests for {@link RandomStringGenerator} > + */ > +public class RandomStringGeneratorTest { > + > + private static int codePointLength(String s) { > + return s.codePointCount(0, s.length()); > + } > + > + private static final CharacterPredicate A_FILTER = new > CharacterPredicate() { > + @Override > + public boolean test(int codePoint) { > + return codePoint == 'a'; > + } > + }; > + > + private static final CharacterPredicate B_FILTER = new > CharacterPredicate() { > + @Override > + public boolean test(int codePoint) { > + return codePoint == 'b'; > + } > + }; > + > + @Test(expected = IllegalArgumentException.class) > + public void testInvalidLength() throws Exception { > + RandomStringGenerator generator = new > RandomStringGenerator.Builder().build(); > + generator.generate(-1); > + } > + > + @Test > + public void testSetLength() throws Exception { > + final int length = 99; > + RandomStringGenerator generator = new > RandomStringGenerator.Builder().build(); > + String str = generator.generate(length); > + assertEquals(length, codePointLength(str)); > + } > + > + @Test(expected = IllegalArgumentException.class) > + public void testBadMinimumCodePoint() throws Exception { > + new RandomStringGenerator.Builder().withinRange(-1, 1); > + } > + > + @Test(expected = IllegalArgumentException.class) > + public void testBadMaximumCodePoint() throws Exception { > + new RandomStringGenerator.Builder().withinRange(0, > Character.MAX_CODE_POINT + 1); > + } > + > + @Test > + public void testWithinRange() throws Exception { > + final int length = 5000; > + final int minimumCodePoint = 'a'; > + final int maximumCodePoint = 'z'; > + RandomStringGenerator generator = new > RandomStringGenerator.Builder().withinRange(minimumCodePoint,maximumCodePoint).build(); > + String str = generator.generate(length); > + > + int i = 0; > + do { > + int codePoint = str.codePointAt(i); > + assertTrue(codePoint >= minimumCodePoint && codePoint <= > maximumCodePoint); > + i += Character.charCount(codePoint); > + } while (i < str.length()); > + > + } > + > + @Test > + public void testNoLoneSurrogates() throws Exception { > + final int length = 5000; > + String str = new > RandomStringGenerator.Builder().build().generate(length); > + > + char lastChar = str.charAt(0); > + for (int i = 1; i < str.length(); i++) { > + char c = str.charAt(i); > + > + if (Character.isLowSurrogate(c)) { > + assertTrue(Character.isHighSurrogate(lastChar)); > + } > + > + if (Character.isHighSurrogate(lastChar)) { > + assertTrue(Character.isLowSurrogate(c)); > + } > + > + if (Character.isHighSurrogate(c)) { > + // test this isn't the last character in the string > + assertTrue(i + 1 < str.length()); > + } > + > + lastChar = c; > + } > + } > + > + @Test > + public void testUsingRandom() throws Exception { > + final char testChar = 'a'; > + final Random testRandom = new Random() { > + private static final long serialVersionUID = 1L; > + > + @Override > + public int nextInt(int n) { > + return testChar; > + } > + }; > + > + String str = new > RandomStringGenerator.Builder().usingRandom(testRandom).build().generate(10); > + for (char c : str.toCharArray()) { > + assertEquals(testChar, c); > + } > + } > + > + @Test > + public void testMultipleFilters() throws Exception { > + String str = new RandomStringGenerator.Builder().withinRange('a','d') > + .filteredBy(A_FILTER, B_FILTER).build().generate(5000); > + > + boolean aFound = false; > + boolean bFound = false; > + > + for (char c : str.toCharArray()) { > + if (c == 'a') { > + aFound = true; > + } else if (c == 'b') { > + bFound = true; > + } else { > + fail("Invalid character"); > + } > + } > + > + assertTrue(aFound && bFound); > + } > + > + @Test > + public void testNoPrivateCharacters() throws Exception { > + final int startOfPrivateBMPChars = 0xE000; > + > + // Request a string in an area of the Basic Multilingual Plane that > is > + // largely > + // occupied by private characters > + String str = new > RandomStringGenerator.Builder().withinRange(startOfPrivateBMPChars, > + Character.MIN_SUPPLEMENTARY_CODE_POINT - > 1).build().generate(5000); > + > + int i = 0; > + do { > + int codePoint = str.codePointAt(i); > + assertFalse(Character.getType(codePoint) == > Character.PRIVATE_USE); > + i += Character.charCount(codePoint); > + } while (i < str.length()); > + } > + > + @Test(expected = IllegalArgumentException.class) > + public void testBadMinAndMax() throws Exception { > + new RandomStringGenerator.Builder().withinRange(2, 1); > + } > + > + @Test > + public void testRemoveFilters() throws Exception { > + > + RandomStringGenerator.Builder builder = new > RandomStringGenerator.Builder().withinRange('a', 'z') > + .filteredBy(A_FILTER); > + > + builder.filteredBy(); > + > + String str = builder.build().generate(100); > + for (char c : str.toCharArray()) { > + if (c != 'a') { > + // filter was successfully removed > + return; > + } > + } > + > + fail("Filter appears to have remained in place"); > + } > + > + @Test > + public void testChangeOfFilter() throws Exception { > + RandomStringGenerator.Builder builder = new > RandomStringGenerator.Builder().withinRange('a', 'z') > + .filteredBy(A_FILTER); > + String str = builder.filteredBy(B_FILTER).build().generate(100); > + > + for (char c : str.toCharArray()) { > + assertTrue(c == 'b'); > + } > + } > +} > --------------------------------------------------------------------- To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org For additional commands, e-mail: dev-h...@commons.apache.org
