iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup work

This commit is contained in:
eugenp 2013-12-21 15:25:50 +02:00
parent 611dd456b6
commit c9d4d73b48
8 changed files with 2 additions and 752 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
jackson/src/test/java/org/baeldung/guava/GuavaCollectionsExamplesTest.java
View File

@ -1,189 +0,0 @@
package org.baeldung.guava;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import org.junit.Test;
import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
@SuppressWarnings("unused")
public class GuavaCollectionsExamplesTest {
// tests
@Test
public final void whenDowncastingGenerifiedCollectionToNewGenerifiedCollection_thenCastIsOK() {
final class CastFunction<F, T extends F> implements Function<F, T> {
@SuppressWarnings("unchecked")
@Override
public final T apply(final F from) {
return (T) from;
}
}
final List<Number> originalList = Lists.newArrayList();
final List<Integer> selectedProducts = Lists.transform(originalList, new CastFunction<Number, Integer>());
System.out.println(selectedProducts);
}
@SuppressWarnings({ "unchecked" })
@Test
public final void whenDowncastingGenerifiedCollectionToNewGenerifiedCollection_thenCastIsOK2() {
final List<Number> originalList = Lists.newArrayList();
final List<Integer> selectedProducts = (List<Integer>) (List<? extends Number>) originalList;
System.out.println(selectedProducts);
}
@Test
public final void whenAddingAnIterableToACollection_thenAddedOK() {
final Iterable<String> iter = Lists.newArrayList();
final Collection<String> collector = Lists.newArrayList();
Iterables.addAll(collector, iter);
}
//
@Test
public final void whenCheckingIfCollectionContainsElementsByCustomMatch1_thenContains() {
final Iterable<String> theCollection = Lists.newArrayList("a", "bc", "def");
final boolean contains = Iterables.any(theCollection, new Predicate<String>() {
@Override
public final boolean apply(final String input) {
return input.length() == 1;
}
});
assertTrue(contains);
}
@Test
public final void whenCheckingIfCollectionContainsElementsByCustomMatch2_thenContains() {
final Set<String> theCollection = Sets.newHashSet("a", "bc", "def");
final boolean contains = !Sets.filter(theCollection, new Predicate<String>() {
@Override
public final boolean apply(final String input) {
return input.length() == 1;
}
}).isEmpty();
assertTrue(contains);
}
@Test
public final void whenCheckingIfCollectionContainsElementsByCustomMatch3_thenContains() {
final Iterable<String> theCollection = Sets.newHashSet("a", "bc", "def");
final boolean contains = Iterables.find(theCollection, new Predicate<String>() {
@Override
public final boolean apply(final String input) {
return input.length() == 1;
}
}) != null;
assertTrue(contains);
}
//
@Test(expected = NoSuchElementException.class)
public final void givenNoSearchResult_whenFindingElementInIterable_thenException() {
final Iterable<String> theCollection = Sets.newHashSet("abcd", "efgh", "ijkl");
final String found = Iterables.find(theCollection, new Predicate<String>() {
@Override
public final boolean apply(final String input) {
return input.length() == 1;
}
});
assertNull(found);
}
@Test
public final void givenNoSearchResult_whenFindingElementInIterableWithSpecifiedReturn_thenNoException() {
final Iterable<String> theCollection = Sets.newHashSet("abcd", "efgh", "ijkl");
final Predicate<String> inputOfLengthOne = new Predicate<String>() {
@Override
public final boolean apply(final String input) {
return input.length() == 1;
}
};
final String found = Iterables.find(theCollection, inputOfLengthOne, null);
assertNull(found);
}
// purge of nulls
@Test
public final void givenListContainsNulls_whenPurgedOfNulls_thenNoLongerContainsNulls() {
final List<String> values = Lists.newArrayList("a", null, "b", "c");
final Iterable<String> withoutNulls = Iterables.filter(values, Predicates.notNull());
System.out.println(withoutNulls);
}
// immutable collections
@Test
public final void whenCreatingImuutableCollections_thenNoExceptions() {
final ImmutableList<String> immutableList = ImmutableList.of("a", "b", "c");
final ImmutableSet<String> immutableSet = ImmutableSet.of("a", "b", "c");
final ImmutableMap<String, String> imuttableMap = ImmutableMap.of("k1", "v1", "k2", "v2", "k3", "v3");
}
@Test
public final void whenTransformingCollectionsToImmutable_thenNoExceptions() {
final List<String> muttableList = Lists.newArrayList();
final ImmutableList<String> immutableList = ImmutableList.copyOf(muttableList);
final Set<String> muttableSet = Sets.newHashSet();
final ImmutableSet<String> immutableSet = ImmutableSet.copyOf(muttableSet);
final Map<String, String> muttableMap = Maps.newHashMap();
final ImmutableMap<String, String> imuttableMap = ImmutableMap.copyOf(muttableMap);
}
@Test
public final void whenTransformingCollectionsToImmutableViaBuilders_thenNoExceptions() {
final List<String> muttableList = Lists.newArrayList();
final ImmutableList<String> immutableList = ImmutableList.<String> builder().addAll(muttableList).build();
final Set<String> muttableSet = Sets.newHashSet();
final ImmutableSet<String> immutableSet = ImmutableSet.<String> builder().addAll(muttableSet).build();
final Map<String, String> muttableMap = Maps.newHashMap();
final ImmutableMap<String, String> imuttableMap = ImmutableMap.<String, String> builder().putAll(muttableMap).build();
}
// unmodifiable
@Test(expected = UnsupportedOperationException.class)
public final void givenUnmodifiableViewOverIterable_whenTryingToRemove_thenNotAllowed() {
final List<Integer> numbers = Lists.newArrayList(1, 2, 3);
final Iterable<Integer> unmodifiableIterable = Iterables.unmodifiableIterable(numbers);
final Iterator<Integer> iterator = unmodifiableIterable.iterator();
if (iterator.hasNext()) {
iterator.remove();
}
}
}

186
jackson/src/test/java/org/baeldung/guava/GuavaFunctionalExamplesTest.java
View File

@ -1,186 +0,0 @@
package org.baeldung.guava;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.lessThan;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Collections2;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Ordering;
import com.google.common.collect.Sets;
public class GuavaFunctionalExamplesTest {
// tests
// predicates - filtering
@Test
public final void whenFilteringNumbersAccordingToACondition_thenCorrectResults() {
final List<Integer> numbers = Lists.newArrayList(1, 2, 3, 6, 8, 10, 34, 57, 89);
final Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) == 0;
}
};
final List<Integer> evenNumbers = Lists.newArrayList(Collections2.filter(numbers, acceptEvenNumber));
final Integer found = Collections.binarySearch(evenNumbers, 57);
assertThat(found, lessThan(0));
}
@Test
public final void givenCollectionContainsNulls_whenNullsAreFilteredOut_thenResultingCollectionsHasNoNulls() {
final List<String> withNulls = Lists.newArrayList("a", "bc", null, "def");
final Iterable<String> withoutNuls = Iterables.filter(withNulls, Predicates.notNull());
assertTrue(Iterables.all(withoutNuls, Predicates.notNull()));
}
// predicates - checking
@Test
public final void givenEvenNumbers_whenCheckingIfAllSatisfyTheEvenPredicate_thenYes() {
final List<Integer> evenNumbers = Lists.newArrayList(2, 6, 8, 10, 34, 90);
final Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) == 0;
}
};
assertTrue(Iterables.all(evenNumbers, acceptEvenNumber));
}
// negating a predicate
@Test
public final void givenCollectionOfEvenNumbers_whenCheckingThatCollectionContainsNoOddNumber_thenTrue() {
final List<Integer> evenNumbers = Lists.newArrayList(2, 6, 8, 10, 34, 90);
final Predicate<Integer> acceptOddNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) != 0;
}
};
assertTrue(Iterables.all(evenNumbers, Predicates.not(acceptOddNumber)));
}
// other predicates
@Test
public final void when_thenCorrect() {
// CharMatcher.forPredicate(predicate)
}
// functions
@Test
public final void whenApplyingSimpleFunctionToInputs_thenCorrectlyTransformed() {
final List<Integer> numbers = Lists.newArrayList(1, 2, 3);
final List<String> numbersAsStrings = Lists.transform(numbers, Functions.toStringFunction());
assertThat(numbersAsStrings, contains("1", "2", "3"));
}
@Test
public final void whenUsingAnIntermediaryFunctionToOrder_thenCorerctlyOrderedInAlphabeticalOrder() {
final List<Integer> numbersToSort = Arrays.asList(2, 1, 11, 100, 8, 14);
final Ordering<Object> ordering = Ordering.natural().onResultOf(Functions.toStringFunction());
final List<Integer> inAlphabeticalOrder = ordering.sortedCopy(numbersToSort);
final List<Integer> correctAlphabeticalOrder = Lists.newArrayList(1, 100, 11, 14, 2, 8);
assertThat(correctAlphabeticalOrder, equalTo(inAlphabeticalOrder));
}
@Test
public final void whenChainingPredicatesAndFunctions_thenCorrectResults() {
final List<Integer> numbers = Arrays.asList(2, 1, 11, 100, 8, 14);
final Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) == 0;
}
};
final Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
@Override
public final Integer apply(final Integer input) {
return (int) Math.pow(input, 2);
}
};
final FluentIterable<Integer> powerOfTwoOnlyForEvenNumbers = FluentIterable.from(numbers).filter(acceptEvenNumber).transform(powerOfTwo);
assertThat(powerOfTwoOnlyForEvenNumbers, contains(4, 10000, 64, 196));
}
@Test
public final void whenUsingFunctionComposition_thenCorrectResults() {
final List<Integer> numbers = Arrays.asList(2, 3);
final Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
@Override
public final Integer apply(final Integer input) {
return (int) Math.pow(input, 2);
}
};
final List<Integer> result = Lists.transform(numbers, Functions.compose(powerOfTwo, powerOfTwo));
assertThat(result, contains(16, 81));
}
// Set+Function => Map
/**
* - see: http://code.google.com/p/guava-libraries/issues/detail?id=56
*/
@Test
public final void whenMapIsBackedBySetAndFunction_thenCorrect() {
final Function<Integer, Integer> powerOfTwo = new Function<Integer, Integer>() {
@Override
public final Integer apply(final Integer input) {
return (int) Math.pow(input, 2);
}
};
final Set<Integer> lowNumbers = Sets.newHashSet(2, 3, 4);
final Map<Integer, Integer> numberToPowerOfTwoMuttable = Maps.asMap(lowNumbers, powerOfTwo);
final Map<Integer, Integer> numberToPowerOfTwoImuttable = Maps.toMap(lowNumbers, powerOfTwo);
assertThat(numberToPowerOfTwoMuttable.get(2), equalTo(4));
assertThat(numberToPowerOfTwoImuttable.get(2), equalTo(4));
}
// Predicate => Function
@Test
public final void whenConvertingPredicateToFunction_thenCorrect() {
final List<Integer> numbers = Lists.newArrayList(1, 2, 3, 6);
final Predicate<Integer> acceptEvenNumber = new Predicate<Integer>() {
@Override
public final boolean apply(final Integer number) {
return (number % 2) == 0;
}
};
final Function<Integer, Boolean> isEventNumberFunction = Functions.forPredicate(acceptEvenNumber);
final List<Boolean> areNumbersEven = Lists.transform(numbers, isEventNumberFunction);
assertThat(areNumbersEven, contains(false, true, false, true));
}
}

179
jackson/src/test/java/org/baeldung/guava/GuavaOrderingExamplesTest.java
View File

@ -1,179 +0,0 @@
package org.baeldung.guava;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import com.google.common.base.Functions;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;
import com.google.common.primitives.Ints;
public class GuavaOrderingExamplesTest {
private final class OrderingByLenght extends Ordering<String> {
@Override
public final int compare(final String s1, final String s2) {
return Ints.compare(s1.length(), s2.length());
}
}
// tests
// dealing with null
@Test
public final void givenCollectionWithNulls_whenSortingWithNullsLast_thenNullsAreLast() {
final List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast());
assertThat(toSort.get(toSort.size() - 1), nullValue());
}
@Test
public final void givenCollectionWithNulls_whenSortingWithNullsFirst_thenNullsAreFirst() {
final List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsFirst());
assertThat(toSort.get(0), nullValue());
}
@Test
public final void whenCollectionIsSortedNullsLastReversed_thenNullAreFirst() {
final List<Integer> toSort = Arrays.asList(3, 5, 4, null, 1, 2);
Collections.sort(toSort, Ordering.natural().nullsLast().reverse());
assertThat(toSort.get(0), nullValue());
}
// natural ordering
@Test
public final void whenSortingWithNaturalOrdering_thenCorectlySorted() {
final List<Integer> toSort = Arrays.asList(3, 5, 4, 1, 2);
Collections.sort(toSort, Ordering.natural());
assertTrue(Ordering.natural().isOrdered(toSort));
}
// checking string ordering
@Test
public final void givenCollectionContainsDuplicates_whenCheckingStringOrdering_thenNo() {
final List<Integer> toSort = Arrays.asList(3, 5, 4, 2, 1, 2);
Collections.sort(toSort, Ordering.natural());
assertFalse(Ordering.natural().isStrictlyOrdered(toSort));
}
// custom - by length
@Test
public final void givenCollectionIsSorted_whenUsingOrderingApiToCheckOrder_thenCheckCanBePerformed() {
final List<String> toSort = Arrays.asList("zz", "aa", "b", "ccc");
final Ordering<String> byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);
final Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));
}
@Test
public final void whenSortingCollectionsOfStringsByLenght_thenCorrectlySorted() {
final List<String> toSort = Arrays.asList("zz", "aa", "b", "ccc");
final Ordering<String> byLength = new OrderingByLenght();
Collections.sort(toSort, byLength);
final Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "zz", "aa", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));
}
@Test
public final void whenSortingCollectionsOfStringsByLenghtWithSecondaryNaturalOrdering_thenCorrectlySorted() {
final List<String> toSort = Arrays.asList("zz", "aa", "b", "ccc");
final Ordering<String> byLength = new OrderingByLenght();
Collections.sort(toSort, byLength.compound(Ordering.natural()));
final Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "zz", "ccc"));
assertTrue(expectedOrder.isOrdered(toSort));
}
@Test
public final void whenSortingCollectionsWithComplexOrderingExample_thenCorrectlySorted() {
final List<String> toSort = Arrays.asList("zz", "aa", null, "b", "ccc");
Collections.sort(toSort, new OrderingByLenght().reverse().compound(Ordering.natural()).nullsLast());
System.out.println(toSort);
}
// sorted copy
@Test
public final void givenUnorderdList_whenRetrievingSortedCopy_thenSorted() {
final List<String> toSort = Arrays.asList("aa", "b", "ccc");
final List<String> sortedCopy = new OrderingByLenght().sortedCopy(toSort);
final Ordering<String> expectedOrder = Ordering.explicit(Lists.newArrayList("b", "aa", "ccc"));
assertFalse(expectedOrder.isOrdered(toSort));
assertTrue(expectedOrder.isOrdered(sortedCopy));
}
// to string
@Test
public final void givenUnorderdList_whenUsingToStringForSortingObjects_thenSortedWithToString() {
final List<Integer> toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());
final Ordering<Integer> expectedOrder = Ordering.explicit(Lists.newArrayList(1, 11, 2));
assertTrue(expectedOrder.isOrdered(toSort));
}
// binary search
@Test
public final void whenPerformingBinarySearch_thenFound() {
final List<Integer> toSort = Arrays.asList(1, 2, 11);
Collections.sort(toSort, Ordering.usingToString());
final int found = Ordering.usingToString().binarySearch(toSort, 2);
System.out.println(found);
}
// min/max without actually sorting
@Test
public final void whenFindingTheMinimalElementWithoutSorting_thenFound() {
final List<Integer> toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
final int found = Ordering.natural().min(toSort);
assertThat(found, equalTo(1));
}
@Test
public final void whenFindingTheFirstFewElements_thenCorrect() {
final List<Integer> toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
final List<Integer> leastOf = Ordering.natural().leastOf(toSort, 3);
final List<Integer> expected = Lists.newArrayList(1, 2, 8);
assertThat(expected, equalTo(leastOf));
}
// order the results of a Function
@Test
public final void givenListOfNumbers_whenRunningAToStringFunctionThenSorting_thenCorrect() {
final List<Integer> toSort = Arrays.asList(2, 1, 11, 100, 8, 14);
final Ordering<Object> ordering = Ordering.natural().onResultOf(Functions.toStringFunction());
final List<Integer> sortedCopy = ordering.sortedCopy(toSort);
final List<Integer> expected = Lists.newArrayList(1, 100, 11, 14, 2, 8);
assertThat(expected, equalTo(sortedCopy));
}
}

97
jackson/src/test/java/org/baeldung/hamcrest/HamcrestExamplesTest.java
View File

@ -1,97 +0,0 @@
package org.baeldung.hamcrest;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.emptyArray;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.everyItem;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.hasItems;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.hamcrest.Matchers;
import org.junit.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
public class HamcrestExamplesTest {
// tests
@Test
public final void whenVerifyingSingleElementIsPartOfCollection_thenCorrect() {
final List<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, hasItem("cd"));
assertThat(collection, not(hasItem("zz")));
}
@Test
public final void whenVerifyingMultipleElementsArePartOfCollection_thenCorrect1() {
final List<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, hasItems("ef", "cd"));
}
@Test
public final void whenVerifyingMultipleElementsArePartOfCollectionInStrictOrder_thenCorrect2() {
final List<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, contains("ab", "cd", "ef"));
}
@Test
public final void whenVerifyingMultipleElementsArePartOfCollectionInAnyOrder_thenCorrect2() {
final List<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, containsInAnyOrder("cd", "ab", "ef"));
}
@Test
public final void givenCollectionIsEmpty_whenChecking_thenEmpty() {
final List<String> collection = Lists.newArrayList();
assertThat(collection, empty());
}
@Test
public final void givenCollectionIsNotEmpty_whenChecking_thenNotEmpty() {
final List<String> collection = Lists.newArrayList("a");
assertThat(collection, not(empty()));
}
@Test
public final void givenMapIsEmpty_whenChecking_thenEmpty() {
final Map<String, String> collection = Maps.newHashMap();
assertThat(collection, equalTo(Collections.EMPTY_MAP));
}
@Test
public final void givenArrayIsEmpty_whenChecking_thenEmpty() {
final String[] array = new String[] { "ab" };
assertThat(array, not(emptyArray()));
}
@Test
public final void whenCollectionSizeIsChecked_thenCorrect() {
final List<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, hasSize(3));
}
@Test
public final void whenIterableSizeIsChecked_thenCorrect() {
final Iterable<String> collection = Lists.newArrayList("ab", "cd", "ef");
assertThat(collection, Matchers.<String> iterableWithSize(3));
}
@Test
public final void whenCheckingConditionOverEachItem_thenCorrect() {
final List<Integer> collection = Lists.newArrayList(15, 20, 25, 30);
assertThat(collection, everyItem(greaterThan(10)));
}
}

2
jackson/src/test/java/jackson/FooDto.java → jackson/src/test/java/org/baeldung/jackson/FooDto.java
View File

@ -1,4 +1,4 @@
package jackson;
package org.baeldung.jackson;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;

2
jackson/src/test/java/jackson/JacksonUnitTest.java → jackson/src/test/java/org/baeldung/jackson/JacksonUnitTest.java
View File

@ -1,4 +1,4 @@
package jackson;
package org.baeldung.jackson;
import java.io.IOException;

43
jackson/src/test/java/org/baeldung/java/CollectionApachePartitionUnitTest.java
View File

@ -1,43 +0,0 @@
package org.baeldung.java;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import java.util.List;
import org.apache.commons.collections4.ListUtils;
import org.junit.Test;
import com.google.common.collect.Lists;
public class CollectionApachePartitionUnitTest {
// tests - apache common collections
@Test
public final void givenList_whenParitioningIntoNSublists_thenCorrect() {
final List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
final List<List<Integer>> subSets = ListUtils.partition(intList, 3);
// When
final List<Integer> lastPartition = subSets.get(2);
final List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
assertThat(subSets.size(), equalTo(3));
assertThat(lastPartition, equalTo(expectedLastPartition));
}
@Test
public final void givenListPartitioned_whenOriginalListIsModified_thenPartitionsChange() {
// Given
final List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
final List<List<Integer>> subSets = ListUtils.partition(intList, 3);
// When
intList.add(9);
final List<Integer> lastPartition = subSets.get(2);
final List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8, 9);
assertThat(lastPartition, equalTo(expectedLastPartition));
}
}

56
jackson/src/test/java/org/baeldung/java/CollectionGuavaPartitionUnitTest.java
View File

@ -1,56 +0,0 @@
package org.baeldung.java;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import java.util.Collection;
import java.util.List;
import org.junit.Test;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
public class CollectionGuavaPartitionUnitTest {
// tests - guava
@Test
public final void givenList_whenParitioningIntoNSublists_thenCorrect() {
final List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
final List<List<Integer>> subSets = Lists.partition(intList, 3);
// When
final List<Integer> lastPartition = subSets.get(2);
final List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8);
assertThat(subSets.size(), equalTo(3));
assertThat(lastPartition, equalTo(expectedLastPartition));
}
@Test
public final void givenListPartitioned_whenOriginalListIsModified_thenPartitionsChangeAsWell() {
// Given
final List<Integer> intList = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
final List<List<Integer>> subSets = Lists.partition(intList, 3);
// When
intList.add(9);
final List<Integer> lastPartition = subSets.get(2);
final List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(7, 8, 9);
assertThat(lastPartition, equalTo(expectedLastPartition));
}
@Test
public final void givenCollection_whenParitioningIntoNSublists_thenCorrect() {
final Collection<Integer> intCollection = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8);
final Iterable<List<Integer>> subSets = Iterables.partition(intCollection, 3);
// When
final List<Integer> firstPartition = subSets.iterator().next();
final List<Integer> expectedLastPartition = Lists.<Integer> newArrayList(1, 2, 3);
assertThat(firstPartition, equalTo(expectedLastPartition));
}
}