From af887abbb0707ec9e3d31dd509b63c9df69d6149 Mon Sep 17 00:00:00 2001 From: Donald Raab Date: Wed, 30 Sep 2015 19:54:30 +0000 Subject: [PATCH] [GSCOLLECT-1649] Add more tests to StringIterateTest and simplify toStringBuilder for CharAdapter and CodePointAdapter. git-svn-id: svn+ssh://gscollections.svn.services.gs.com/svnroot/gscollections-svn/trunk@898 d5c9223b-1aff-41ac-aadd-f810b4a99ac4 --- .../impl/string/immutable/CharAdapter.java | 8 +- .../string/immutable/CodePointAdapter.java | 10 +- .../impl/utility/StringIterateTest.java | 148 +++++++++++++++++- 3 files changed, 147 insertions(+), 19 deletions(-) diff --git a/collections/src/main/java/com/gs/collections/impl/string/immutable/CharAdapter.java b/collections/src/main/java/com/gs/collections/impl/string/immutable/CharAdapter.java index 6ecef08c3..2522e5723 100644 --- a/collections/src/main/java/com/gs/collections/impl/string/immutable/CharAdapter.java +++ b/collections/src/main/java/com/gs/collections/impl/string/immutable/CharAdapter.java @@ -97,13 +97,7 @@ public String subSequence(int start, int end) public StringBuilder toStringBuilder() { - StringBuilder builder = new StringBuilder(); - int size = this.size(); - for (int i = 0; i < size; i++) - { - builder.append(this.get(i)); - } - return builder; + return new StringBuilder(this.adapted); } /** diff --git a/collections/src/main/java/com/gs/collections/impl/string/immutable/CodePointAdapter.java b/collections/src/main/java/com/gs/collections/impl/string/immutable/CodePointAdapter.java index 6ac3ee7de..627a24809 100644 --- a/collections/src/main/java/com/gs/collections/impl/string/immutable/CodePointAdapter.java +++ b/collections/src/main/java/com/gs/collections/impl/string/immutable/CodePointAdapter.java @@ -109,15 +109,7 @@ public String subSequence(int start, int end) public StringBuilder toStringBuilder() { - StringBuilder builder = new StringBuilder(); - int length = this.adapted.length(); - for (int i = 0; i < length; ) - { - int codePoint = this.adapted.codePointAt(i); - builder.appendCodePoint(codePoint); - i += Character.charCount(codePoint); - } - return builder; + return new StringBuilder(this.adapted); } @Override diff --git a/unit-tests/src/test/java/com/gs/collections/impl/utility/StringIterateTest.java b/unit-tests/src/test/java/com/gs/collections/impl/utility/StringIterateTest.java index de51ed702..95e0b8d9f 100644 --- a/unit-tests/src/test/java/com/gs/collections/impl/utility/StringIterateTest.java +++ b/unit-tests/src/test/java/com/gs/collections/impl/utility/StringIterateTest.java @@ -25,6 +25,9 @@ import com.gs.collections.api.list.primitive.IntList; import com.gs.collections.api.map.MutableMap; import com.gs.collections.api.set.MutableSet; +import com.gs.collections.api.set.primitive.ImmutableCharSet; +import com.gs.collections.api.set.primitive.ImmutableIntSet; +import com.gs.collections.api.tuple.Twin; import com.gs.collections.impl.block.factory.Functions; import com.gs.collections.impl.block.factory.Procedures; import com.gs.collections.impl.block.factory.primitive.CharPredicates; @@ -34,6 +37,8 @@ import com.gs.collections.impl.block.predicate.CodePointPredicate; import com.gs.collections.impl.block.procedure.primitive.CodePointProcedure; import com.gs.collections.impl.factory.Lists; +import com.gs.collections.impl.factory.primitive.CharSets; +import com.gs.collections.impl.factory.primitive.IntSets; import com.gs.collections.impl.list.mutable.FastList; import com.gs.collections.impl.list.mutable.primitive.CharArrayList; import com.gs.collections.impl.set.mutable.UnifiedSet; @@ -50,6 +55,12 @@ */ public class StringIterateTest { + public static final String THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG = "The quick brown fox jumps over the lazy dog."; + public static final String ALPHABET_LOWERCASE = "abcdefghijklmnopqrstuvwxyz"; + public static final Twin HALF_ABET = StringIterate.splitAtIndex(ALPHABET_LOWERCASE, 13); + public static final String TQBFJOTLD_MINUS_HALF_ABET_1 = "t qu rown ox ups ovr t zy o."; + public static final String TQBFJOTLD_MINUS_HALF_ABET_2 = "he ick b f jm e he la dg."; + @Test public void asCharAdapter() { @@ -90,16 +101,66 @@ public void asCharAdapter() .chars() .sorted() .forEach(e -> arraylist.add((char) e)); - Assert.assertEquals(CharArrayList.newListWith('E', 'H', 'L', 'L', 'O'), arraylist); + Assert.assertEquals(StringIterate.asCharAdapter("EHLLO"), arraylist); ImmutableCharList arrayList2 = StringIterate.asCharAdapter("Hello".toUpperCase()) .toSortedList() .toImmutable(); - Assert.assertEquals(CharArrayList.newListWith('E', 'H', 'L', 'L', 'O'), arrayList2); + Assert.assertEquals(StringIterate.asCharAdapter("EHLLO"), arrayList2); - Assert.assertEquals(CharArrayList.newListWith('H', 'E', 'L', 'L', 'O'), CharAdapter.adapt("hello").collectChar(Character::toUpperCase)); + Assert.assertEquals(StringIterate.asCharAdapter("HELLO"), CharAdapter.adapt("hello").collectChar(Character::toUpperCase)); + } + + @Test + public void asCharAdapterExtra() + { + Assert.assertEquals(9, + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(c -> !Character.isLetter(c))); + + Assert.assertTrue( + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).anySatisfy(Character::isWhitespace)); + + Assert.assertEquals(8, + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(Character::isWhitespace)); + + Verify.assertSize(26, + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .asLazy() + .select(Character::isLetter) + .collectChar(Character::toLowerCase).toSet()); + + ImmutableCharSet alphaCharAdapter = + StringIterate.asCharAdapter(ALPHABET_LOWERCASE).toSet().toImmutable(); + Assert.assertTrue( + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).containsAll(alphaCharAdapter)); + Assert.assertEquals( + CharSets.immutable.empty(), + alphaCharAdapter.newWithoutAll(StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()))); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_1, + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.asCharAdapter(HALF_ABET.getOne())) + .toString()); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_2, + StringIterate.asCharAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.asCharAdapter(HALF_ABET.getTwo())) + .toString()); + } + + @Test + public void buildTheAlphabetFromEmpty() + { + String alphabet = StringIterate.asCharAdapter("") + .newWith('a') + .newWithAll(StringIterate.asCharAdapter(HALF_ABET.getOne())) + .newWithAll(StringIterate.asCharAdapter(HALF_ABET.getTwo())) + .newWithout('a').toString(); + Assert.assertEquals(ALPHABET_LOWERCASE, alphabet); } @Test @@ -132,6 +193,45 @@ public void asCodePointAdapter() Assert.assertEquals("OH!", CodePointAdapter.from(CodePointAdapter.from(intList)).toString()); } + @Test + public void asCodePointAdapterExtra() + { + Assert.assertEquals(9, + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(i -> !Character.isLetter(i))); + + Assert.assertTrue( + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).anySatisfy(Character::isWhitespace)); + + Assert.assertEquals(8, + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(Character::isWhitespace)); + + Verify.assertSize(26, + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .asLazy() + .select(Character::isLetter) + .collectInt(Character::toLowerCase).toSet()); + + ImmutableIntSet alphaints = + StringIterate.asCodePointAdapter(ALPHABET_LOWERCASE).toSet().toImmutable(); + Assert.assertTrue( + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).containsAll(alphaints)); + Assert.assertEquals( + IntSets.immutable.empty(), + alphaints.newWithoutAll(StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()))); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_1, + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.asCodePointAdapter(HALF_ABET.getOne())) + .toString()); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_2, + StringIterate.asCodePointAdapter(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.asCodePointAdapter(HALF_ABET.getTwo())) + .toString()); + } + @Test public void toCodePointList() { @@ -162,6 +262,48 @@ public void toCodePointList() Assert.assertEquals("OH!", CodePointList.from(CodePointList.from(intList)).toString()); } + @Test + public void toCodePointListExtra() + { + Assert.assertEquals(9, + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(i -> !Character.isLetter(i))); + + Assert.assertTrue( + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).anySatisfy(Character::isWhitespace)); + + Assert.assertEquals(8, + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .count(Character::isWhitespace)); + + Verify.assertSize(26, + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .asLazy() + .select(Character::isLetter) + .collectInt(Character::toLowerCase).toSet()); + + ImmutableIntSet alphaints = + StringIterate.toCodePointList(ALPHABET_LOWERCASE).toSet().toImmutable(); + Assert.assertTrue( + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG).containsAll(alphaints)); + Assert.assertEquals( + IntSets.immutable.empty(), + alphaints.newWithoutAll(StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()))); + Assert.assertTrue( + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG) + .containsAll(StringIterate.toCodePointList(HALF_ABET.getOne()))); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_1, + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.toCodePointList(HALF_ABET.getOne())) + .toString()); + Assert.assertEquals( + TQBFJOTLD_MINUS_HALF_ABET_2, + StringIterate.toCodePointList(THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.toLowerCase()) + .newWithoutAll(StringIterate.toCodePointList(HALF_ABET.getTwo())) + .toString()); + } + @Test public void englishToUpperLowerCase() {