Merge branch 'master' into sla-pr/1104
Conflicts: guava/pom.xml
This commit is contained in:
slavisa-baeldung
@@ -3,6 +3,7 @@ package org.baeldung.guava;
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class GuavaEventBusTest {
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import com.google.common.collect.ArrayListMultimap;
|
||||
import com.google.common.collect.Multimap;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
|
||||
public class GuavaMultiMapTest {
|
||||
|
||||
@Test
|
||||
public void givenMap_whenAddTwoValuesForSameKey_shouldOverridePreviousKey() {
|
||||
//given
|
||||
String key = "a-key";
|
||||
Map<String, String> map = new LinkedHashMap<>();
|
||||
|
||||
//when
|
||||
map.put(key, "firstValue");
|
||||
map.put(key, "secondValue");
|
||||
|
||||
//then
|
||||
assertEquals(1, map.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMultiMap_whenAddTwoValuesForSameKey_shouldHaveTwoEntriesInMap() {
|
||||
//given
|
||||
String key = "a-key";
|
||||
Multimap<String, String> map = ArrayListMultimap.create();
|
||||
|
||||
//when
|
||||
map.put(key, "firstValue");
|
||||
map.put(key, "secondValue");
|
||||
|
||||
//then
|
||||
assertEquals(2, map.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenMapOfListValues_whenAddTwoValuesForSameKey_shouldHaveTwoElementsInList() {
|
||||
//given
|
||||
String key = "a-key";
|
||||
Map<String, List<String>> map = new LinkedHashMap<>();
|
||||
|
||||
//when
|
||||
List<String> values = map.get(key);
|
||||
if(values == null){
|
||||
values = new LinkedList<>();
|
||||
values.add("firstValue");
|
||||
values.add("secondValue");
|
||||
}
|
||||
map.put(key, values);
|
||||
|
||||
//then
|
||||
assertEquals(1, map.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import com.google.common.base.Function;
|
||||
import com.google.common.collect.Ordering;
|
||||
import com.google.common.primitives.Ints;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class GuavaOrderingTest {
|
||||
@Test
|
||||
public void givenListOfIntegers_whenCreateNaturalOrderOrdering_shouldSortProperly() {
|
||||
//given
|
||||
List<Integer> integers = Arrays.asList(3, 2, 1);
|
||||
|
||||
//when
|
||||
integers.sort(Ordering.natural());
|
||||
|
||||
//then
|
||||
assertEquals(Arrays.asList(1, 2, 3), integers);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListOfPersonObject_whenSortedUsingCustomOrdering_shouldSortProperly() {
|
||||
//given
|
||||
List<Person> persons = Arrays.asList(new Person("Michael", 10), new Person("Alice", 3));
|
||||
Ordering<Person> orderingByAge = new Ordering<Person>() {
|
||||
@Override
|
||||
public int compare(Person p1, Person p2) {
|
||||
return Ints.compare(p1.age, p2.age);
|
||||
}
|
||||
};
|
||||
|
||||
//when
|
||||
persons.sort(orderingByAge);
|
||||
|
||||
//then
|
||||
assertEquals(Arrays.asList(new Person("Alice", 3), new Person("Michael", 10)), persons);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListOfPersonObject_whenSortedUsingChainedOrdering_shouldSortPropely() {
|
||||
//given
|
||||
List<Person> persons = Arrays.asList(new Person("Michael", 10), new Person("Alice", 3), new Person("Thomas", null));
|
||||
Ordering<Person> ordering = Ordering.natural().nullsFirst().onResultOf(new Function<Person, Comparable>() {
|
||||
@Override
|
||||
public Comparable apply(Person person) {
|
||||
return person.age;
|
||||
}
|
||||
});
|
||||
|
||||
//when
|
||||
persons.sort(ordering);
|
||||
|
||||
//then
|
||||
assertEquals(Arrays.asList(new Person("Thomas", null), new Person("Alice", 3), new Person("Michael", 10)), persons);
|
||||
}
|
||||
|
||||
|
||||
class Person {
|
||||
private final String name;
|
||||
private final Integer age;
|
||||
|
||||
private Person(String name, Integer age) {
|
||||
this.name = name;
|
||||
this.age = age;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
|
||||
Person person = (Person) o;
|
||||
|
||||
if (name != null ? !name.equals(person.name) : person.name != null) return false;
|
||||
return age != null ? age.equals(person.age) : person.age == null;
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int result = name != null ? name.hashCode() : 0;
|
||||
result = 31 * result + (age != null ? age.hashCode() : 0);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
import java.util.Arrays;
|
||||
import org.junit.Test;
|
||||
import static com.google.common.base.Preconditions.*;
|
||||
|
||||
public class GuavaPreConditionsTest {
|
||||
|
||||
@Test
|
||||
public void whenCheckArgumentEvaluatesFalse_throwsException() {
|
||||
int age = -18;
|
||||
|
||||
assertThatThrownBy(() -> checkArgument(age > 0))
|
||||
.isInstanceOf(IllegalArgumentException.class)
|
||||
.hasMessage(null)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenErrorMessage_whenCheckArgumentEvaluatesFalse_throwsException() {
|
||||
final int age = -18;
|
||||
final String message = "Age can't be zero or less than zero";
|
||||
|
||||
assertThatThrownBy(() -> checkArgument(age > 0, message))
|
||||
.isInstanceOf(IllegalArgumentException.class)
|
||||
.hasMessage(message)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTemplatedErrorMessage_whenCheckArgumentEvaluatesFalse_throwsException() {
|
||||
final int age = -18;
|
||||
final String message = "Age can't be zero or less than zero, you supplied %s.";
|
||||
|
||||
assertThatThrownBy(() -> checkArgument(age > 0, message, age))
|
||||
.isInstanceOf(IllegalArgumentException.class)
|
||||
.hasMessage(message, age)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenCheckElementIndexEvaluatesFalse_throwsException() {
|
||||
final int[] numbers = { 1, 2, 3, 4, 5 };
|
||||
|
||||
assertThatThrownBy(() -> checkElementIndex(6, numbers.length - 1))
|
||||
.isInstanceOf(IndexOutOfBoundsException.class)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegersAndMessage_whenCheckElementIndexEvaluatesFalse_throwsException() {
|
||||
final int[] numbers = { 1, 2, 3, 4, 5 };
|
||||
final String message = "Please check the bound of an array and retry";
|
||||
|
||||
assertThatThrownBy(() -> checkElementIndex(6, numbers.length - 1, message))
|
||||
.isInstanceOf(IndexOutOfBoundsException.class)
|
||||
.hasMessageStartingWith(message)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullString_whenCheckNotNullCalled_throwsException() {
|
||||
final String nullObject = null;
|
||||
|
||||
assertThatThrownBy(() -> checkNotNull(nullObject))
|
||||
.isInstanceOf(NullPointerException.class)
|
||||
.hasMessage(null)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullString_whenCheckNotNullCalledWithMessage_throwsException() {
|
||||
final String nullObject = null;
|
||||
final String message = "Please check the Object supplied, its null!";
|
||||
|
||||
assertThatThrownBy(() -> checkNotNull(nullObject, message))
|
||||
.isInstanceOf(NullPointerException.class)
|
||||
.hasMessage(message)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullString_whenCheckNotNullCalledWithTemplatedMessage_throwsException() {
|
||||
final String nullObject = null;
|
||||
final String message = "Please check the Object supplied, its %s!";
|
||||
|
||||
assertThatThrownBy(() -> checkNotNull(nullObject, message, nullObject))
|
||||
.isInstanceOf(NullPointerException.class)
|
||||
.hasMessage(message, nullObject)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenCheckPositionIndexEvaluatesFalse_throwsException() {
|
||||
final int[] numbers = { 1, 2, 3, 4, 5 };
|
||||
|
||||
assertThatThrownBy(() -> checkPositionIndex(6, numbers.length - 1))
|
||||
.isInstanceOf(IndexOutOfBoundsException.class)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegersAndMessage_whenCheckPositionIndexEvaluatesFalse_throwsException() {
|
||||
final int[] numbers = { 1, 2, 3, 4, 5 };
|
||||
final String message = "Please check the bound of an array and retry";
|
||||
|
||||
assertThatThrownBy(() -> checkPositionIndex(6, numbers.length - 1, message))
|
||||
.isInstanceOf(IndexOutOfBoundsException.class)
|
||||
.hasMessageStartingWith(message)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayOfIntegers_whenCheckPositionIndexesEvaluatesFalse_throwsException() {
|
||||
final int[] numbers = { 1, 2, 3, 4, 5 };
|
||||
|
||||
assertThatThrownBy(() -> checkPositionIndexes(6, 0, numbers.length - 1))
|
||||
.isInstanceOf(IndexOutOfBoundsException.class)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenValidStates_whenCheckStateEvaluatesFalse_throwsException() {
|
||||
final int[] validStates = { -1, 0, 1 };
|
||||
final int givenState = 10;
|
||||
|
||||
assertThatThrownBy(() -> checkState(Arrays.binarySearch(validStates, givenState) > 0))
|
||||
.isInstanceOf(IllegalStateException.class)
|
||||
.hasMessage(null)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenValidStatesAndMessage_whenCheckStateEvaluatesFalse_throwsException() {
|
||||
final int[] validStates = { -1, 0, 1 };
|
||||
final int givenState = 10;
|
||||
final String message = "You have entered an invalid state";
|
||||
|
||||
assertThatThrownBy(() -> checkState(Arrays.binarySearch(validStates, givenState) > 0, message))
|
||||
.isInstanceOf(IllegalStateException.class)
|
||||
.hasMessageStartingWith(message)
|
||||
.hasNoCause();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenValidStatesAndTemplatedMessage_whenCheckStateEvaluatesFalse_throwsException() {
|
||||
final int[] validStates = { -1, 0, 1 };
|
||||
final int givenState = 10;
|
||||
final String message = "State can't be %s, It can be one of %s.";
|
||||
|
||||
assertThatThrownBy(() -> checkState(Arrays.binarySearch(validStates, givenState) > 0, message, givenState, Arrays.toString(validStates)))
|
||||
.isInstanceOf(IllegalStateException.class)
|
||||
.hasMessage(message, givenState, Arrays.toString(validStates))
|
||||
.hasNoCause();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import java.util.Map;
|
||||
import org.junit.Test;
|
||||
import com.google.common.collect.ImmutableRangeMap;
|
||||
import com.google.common.collect.Range;
|
||||
import com.google.common.collect.RangeMap;
|
||||
import com.google.common.collect.TreeRangeMap;
|
||||
|
||||
public class GuavaRangeMapTest {
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenQueryWithinRange_returnsSucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
|
||||
|
||||
assertEquals("Vice President", experienceRangeDesignationMap.get(6));
|
||||
assertEquals("Executive Director", experienceRangeDesignationMap.get(15));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenQueryOutsideRange_returnsNull() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
|
||||
|
||||
assertNull(experienceRangeDesignationMap.get(31));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenRemoveRangeIsCalled_removesSucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
|
||||
experienceRangeDesignationMap.remove(Range.closed(8, 15));
|
||||
experienceRangeDesignationMap.remove(Range.closed(20, 26));
|
||||
|
||||
assertNull(experienceRangeDesignationMap.get(9));
|
||||
assertEquals("Managing Director", experienceRangeDesignationMap.get(16));
|
||||
assertEquals("Managing Director", experienceRangeDesignationMap.get(30));
|
||||
assertNull(experienceRangeDesignationMap.get(25));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenSpanIsCalled_returnsSucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
|
||||
final Range<Integer> experienceSpan = experienceRangeDesignationMap.span();
|
||||
|
||||
assertEquals(0, experienceSpan.lowerEndpoint().intValue());
|
||||
assertEquals(30, experienceSpan.upperEndpoint().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenGetEntryIsCalled_returnsEntrySucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(9, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(20, 30), "Managing Director");
|
||||
final Map.Entry<Range<Integer>, String> experiencEntry = experienceRangeDesignationMap.getEntry(10);
|
||||
|
||||
assertEquals(Range.closed(9, 15), experiencEntry.getKey());
|
||||
assertEquals("Executive Director", experiencEntry.getValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeMap_whenSubRangeMapIsCalled_returnsSubRangeSucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = TreeRangeMap.create();
|
||||
|
||||
experienceRangeDesignationMap.put(Range.closed(0, 2), "Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(3, 5), "Senior Associate");
|
||||
experienceRangeDesignationMap.put(Range.closed(6, 8), "Vice President");
|
||||
experienceRangeDesignationMap.put(Range.closed(8, 15), "Executive Director");
|
||||
experienceRangeDesignationMap.put(Range.closed(16, 30), "Managing Director");
|
||||
final RangeMap<Integer, String> experiencedSubRangeDesignationMap = experienceRangeDesignationMap.subRangeMap(Range.closed(4, 14));
|
||||
|
||||
assertNull(experiencedSubRangeDesignationMap.get(3));
|
||||
assertEquals("Executive Director", experiencedSubRangeDesignationMap.get(14));
|
||||
assertEquals("Vice President", experiencedSubRangeDesignationMap.get(7));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenImmutableRangeMap_whenQueryWithinRange_returnsSucessfully() {
|
||||
final RangeMap<Integer, String> experienceRangeDesignationMap = ImmutableRangeMap.<Integer, String> builder()
|
||||
.put(Range.closed(0, 2), "Associate")
|
||||
.put(Range.closed(3, 5), "Senior Associate")
|
||||
.put(Range.closed(6, 8), "Vice President")
|
||||
.put(Range.closed(9, 15), "Executive Director")
|
||||
.put(Range.closed(16, 30), "Managing Director").build();
|
||||
|
||||
assertEquals("Vice President", experienceRangeDesignationMap.get(6));
|
||||
assertEquals("Executive Director", experienceRangeDesignationMap.get(15));
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void givenImmutableRangeMap_whenRangeOverlaps_ThrowsException() {
|
||||
ImmutableRangeMap.<Integer, String> builder()
|
||||
.put(Range.closed(0, 2), "Associate")
|
||||
.put(Range.closed(3, 5), "Senior Associate")
|
||||
.put(Range.closed(6, 8), "Vice President")
|
||||
.put(Range.closed(8, 15), "Executive Director")
|
||||
.put(Range.closed(16, 30), "Managing Director").build();
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import org.junit.Test;
|
||||
import com.google.common.collect.ImmutableRangeSet;
|
||||
import com.google.common.collect.Range;
|
||||
import com.google.common.collect.RangeSet;
|
||||
import com.google.common.collect.TreeRangeSet;
|
||||
|
||||
public class GuavaRangeSetTest {
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenQueryWithinRange_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 5));
|
||||
numberRangeSet.add(Range.closed(6, 8));
|
||||
|
||||
assertTrue(numberRangeSet.contains(1));
|
||||
assertFalse(numberRangeSet.contains(9));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenEnclosesWithinRange_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 10));
|
||||
numberRangeSet.add(Range.closed(15, 18));
|
||||
|
||||
assertTrue(numberRangeSet.encloses(Range.closed(4, 5)));
|
||||
assertFalse(numberRangeSet.encloses(Range.closed(4, 11)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenComplementIsCalled_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 5));
|
||||
numberRangeSet.add(Range.closed(6, 8));
|
||||
final RangeSet<Integer> numberRangeComplementSet = numberRangeSet.complement();
|
||||
|
||||
assertTrue(numberRangeComplementSet.contains(-1000));
|
||||
assertFalse(numberRangeComplementSet.contains(2));
|
||||
assertFalse(numberRangeComplementSet.contains(3));
|
||||
assertTrue(numberRangeComplementSet.contains(1000));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenIntersectsWithinRange_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 10));
|
||||
numberRangeSet.add(Range.closed(15, 18));
|
||||
|
||||
assertTrue(numberRangeSet.intersects(Range.closed(4, 17)));
|
||||
assertFalse(numberRangeSet.intersects(Range.closed(19, 200)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenRemoveRangeIsCalled_removesSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 5));
|
||||
numberRangeSet.add(Range.closed(6, 8));
|
||||
numberRangeSet.add(Range.closed(9, 15));
|
||||
numberRangeSet.remove(Range.closed(3, 5));
|
||||
numberRangeSet.remove(Range.closed(7, 10));
|
||||
|
||||
assertTrue(numberRangeSet.contains(1));
|
||||
assertFalse(numberRangeSet.contains(9));
|
||||
assertTrue(numberRangeSet.contains(12));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenSpanIsCalled_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 5));
|
||||
numberRangeSet.add(Range.closed(6, 8));
|
||||
final Range<Integer> experienceSpan = numberRangeSet.span();
|
||||
|
||||
assertEquals(0, experienceSpan.lowerEndpoint().intValue());
|
||||
assertEquals(8, experienceSpan.upperEndpoint().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenRangeSet_whenSubRangeSetIsCalled_returnsSubRangeSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
|
||||
|
||||
numberRangeSet.add(Range.closed(0, 2));
|
||||
numberRangeSet.add(Range.closed(3, 5));
|
||||
numberRangeSet.add(Range.closed(6, 8));
|
||||
final RangeSet<Integer> numberSubRangeSet = numberRangeSet.subRangeSet(Range.closed(4, 14));
|
||||
|
||||
assertFalse(numberSubRangeSet.contains(3));
|
||||
assertFalse(numberSubRangeSet.contains(14));
|
||||
assertTrue(numberSubRangeSet.contains(7));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenImmutableRangeSet_whenQueryWithinRange_returnsSucessfully() {
|
||||
final RangeSet<Integer> numberRangeSet = ImmutableRangeSet.<Integer> builder()
|
||||
.add(Range.closed(0, 2))
|
||||
.add(Range.closed(3, 5))
|
||||
.add(Range.closed(6, 8)).build();
|
||||
|
||||
assertTrue(numberRangeSet.contains(6));
|
||||
assertFalse(numberRangeSet.contains(15));
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void givenImmutableRangeMap_whenRangeOverlaps_ThrowsException() {
|
||||
ImmutableRangeSet.<Integer> builder()
|
||||
.add(Range.closed(0, 2))
|
||||
.add(Range.closed(3, 5))
|
||||
.add(Range.closed(5, 8)).build();
|
||||
|
||||
}
|
||||
}
|
||||
@@ -8,10 +8,9 @@ import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.charset.CharsetEncoder;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.*;
|
||||
|
||||
import com.google.common.collect.*;
|
||||
import org.junit.Test;
|
||||
|
||||
import com.google.common.base.CharMatcher;
|
||||
@@ -19,9 +18,6 @@ import com.google.common.base.Function;
|
||||
import com.google.common.base.Joiner;
|
||||
import com.google.common.base.Predicate;
|
||||
import com.google.common.base.Splitter;
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
public class GuavaStringTest {
|
||||
|
||||
|
||||
@@ -0,0 +1,178 @@
|
||||
package org.baeldung.guava;
|
||||
|
||||
import static org.assertj.core.api.Assertions.*;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import org.junit.Test;
|
||||
import com.google.common.collect.ArrayTable;
|
||||
import com.google.common.collect.HashBasedTable;
|
||||
import com.google.common.collect.ImmutableTable;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Table;
|
||||
import com.google.common.collect.TreeBasedTable;
|
||||
|
||||
public class GuavaTableTest {
|
||||
|
||||
@Test
|
||||
public void givenTable_whenGet_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final int seatCount = universityCourseSeatTable.get("Mumbai", "IT");
|
||||
final Integer seatCountForNoEntry = universityCourseSeatTable.get("Oxford", "IT");
|
||||
|
||||
assertThat(seatCount).isEqualTo(60);
|
||||
assertThat(seatCountForNoEntry).isEqualTo(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenContains_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final boolean entryIsPresent = universityCourseSeatTable.contains("Mumbai", "IT");
|
||||
final boolean entryIsAbsent = universityCourseSeatTable.contains("Oxford", "IT");
|
||||
final boolean courseIsPresent = universityCourseSeatTable.containsColumn("IT");
|
||||
final boolean universityIsPresent = universityCourseSeatTable.containsRow("Mumbai");
|
||||
final boolean seatCountIsPresent = universityCourseSeatTable.containsValue(60);
|
||||
|
||||
assertThat(entryIsPresent).isEqualTo(true);
|
||||
assertThat(entryIsAbsent).isEqualTo(false);
|
||||
assertThat(courseIsPresent).isEqualTo(true);
|
||||
assertThat(universityIsPresent).isEqualTo(true);
|
||||
assertThat(seatCountIsPresent).isEqualTo(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenRemove_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
|
||||
final int seatCount = universityCourseSeatTable.remove("Mumbai", "IT");
|
||||
|
||||
assertThat(seatCount).isEqualTo(60);
|
||||
assertThat(universityCourseSeatTable.remove("Mumbai", "IT")).isEqualTo(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenColumn_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final Map<String, Integer> universitySeatMap = universityCourseSeatTable.column("IT");
|
||||
|
||||
assertThat(universitySeatMap).hasSize(2);
|
||||
assertThat(universitySeatMap.get("Mumbai")).isEqualTo(60);
|
||||
assertThat(universitySeatMap.get("Harvard")).isEqualTo(120);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenColumnMap_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final Map<String, Map<String, Integer>> courseKeyUniversitySeatMap = universityCourseSeatTable.columnMap();
|
||||
|
||||
assertThat(courseKeyUniversitySeatMap).hasSize(3);
|
||||
assertThat(courseKeyUniversitySeatMap.get("IT")).hasSize(2);
|
||||
assertThat(courseKeyUniversitySeatMap.get("Electrical")).hasSize(1);
|
||||
assertThat(courseKeyUniversitySeatMap.get("Chemical")).hasSize(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenRow_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final Map<String, Integer> courseSeatMap = universityCourseSeatTable.row("Mumbai");
|
||||
|
||||
assertThat(courseSeatMap).hasSize(2);
|
||||
assertThat(courseSeatMap.get("IT")).isEqualTo(60);
|
||||
assertThat(courseSeatMap.get("Chemical")).isEqualTo(120);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenRowKeySet_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final Set<String> universitySet = universityCourseSeatTable.rowKeySet();
|
||||
|
||||
assertThat(universitySet).hasSize(2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTable_whenColKeySet_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = HashBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final Set<String> courseSet = universityCourseSeatTable.columnKeySet();
|
||||
|
||||
assertThat(courseSet).hasSize(3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeTable_whenGet_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = TreeBasedTable.create();
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final int seatCount = universityCourseSeatTable.get("Mumbai", "IT");
|
||||
|
||||
assertThat(seatCount).isEqualTo(60);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenImmutableTable_whenGet_returnsSuccessfully() {
|
||||
final Table<String, String, Integer> universityCourseSeatTable = ImmutableTable.<String, String, Integer> builder()
|
||||
.put("Mumbai", "Chemical", 120)
|
||||
.put("Mumbai", "IT", 60)
|
||||
.put("Harvard", "Electrical", 60)
|
||||
.put("Harvard", "IT", 120)
|
||||
.build();
|
||||
|
||||
final int seatCount = universityCourseSeatTable.get("Mumbai", "IT");
|
||||
|
||||
assertThat(seatCount).isEqualTo(60);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenArrayTable_whenGet_returnsSuccessfully() {
|
||||
final List<String> universityRowTable = Lists.newArrayList("Mumbai", "Harvard");
|
||||
final List<String> courseColumnTables = Lists.newArrayList("Chemical", "IT", "Electrical");
|
||||
final Table<String, String, Integer> universityCourseSeatTable = ArrayTable.create(universityRowTable, courseColumnTables);
|
||||
universityCourseSeatTable.put("Mumbai", "Chemical", 120);
|
||||
universityCourseSeatTable.put("Mumbai", "IT", 60);
|
||||
universityCourseSeatTable.put("Harvard", "Electrical", 60);
|
||||
universityCourseSeatTable.put("Harvard", "IT", 120);
|
||||
|
||||
final int seatCount = universityCourseSeatTable.get("Mumbai", "IT");
|
||||
|
||||
assertThat(seatCount).isEqualTo(60);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user