JAVA-2154: Create guava-parent module and organize guava modules (#9782)

* JAVA-2154: Removed module, now split into guava-utilities and guava-core

* JAVA-2154: Removed module, articles moved to new module guava-core

* JAVA-2154: Moved module inside guava-modules

* JAVA-2154: Moved module inside guava-modules

* JAVA-2154: Moved module inside guava-modules

* JAVA-2154: Moved module inside guava-modules

* JAVA-2154: Moved 1 article to guava-collections

* JAVA-2154: New module guava-collections-list

* JAVA-2154: New module guava-core

* JAVA-2154: New module guava-utilities

* JAVA-2154: Updated README, removed extra article reference

* JAVA-2154: parent module pom changes

* JAVA-2154: main pom changes - removed guava related modules as they have
been shifted inside guava-modules

* JAVA-2154: rearranged and moved module inside guava-modules folder

guava-modules/guava-collections-map/src/main/java/com/baeldung/guava/mapmaker/Profile.java

@@ -0,0 +1,20 @@
+package com.baeldung.guava.mapmaker;
+
+public class Profile {
+    private long id;
+    private String type;
+
+    public Profile(long id, String type) {
+        this.id = id;
+        this.type = type;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return type;
+    }
+
+}

guava-modules/guava-collections-map/src/main/java/com/baeldung/guava/mapmaker/Session.java

@@ -0,0 +1,13 @@
+package com.baeldung.guava.mapmaker;
+
+public class Session {
+    private long id;
+
+    public Session(long id) {
+        this.id = id;
+    }
+
+    public long getId() {
+        return id;
+    }
+}

guava-modules/guava-collections-map/src/main/java/com/baeldung/guava/mapmaker/User.java

@@ -0,0 +1,20 @@
+package com.baeldung.guava.mapmaker;
+
+public class User {
+    private long id;
+    private String name;
+
+    public User(long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/classtoinstancemap/ClassToInstanceMapUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.guava.classtoinstancemap;
+import com.google.common.collect.ClassToInstanceMap;
+import com.google.common.collect.ImmutableClassToInstanceMap;
+import com.google.common.collect.MutableClassToInstanceMap;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ClassToInstanceMapUnitTest {
+    @Test
+    public void whenOfCalled_thenCreateEmptyImmutableMap() {
+        ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of();
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    public void whenCreateCalled_thenCreateEmptyMutableMap() {
+        ClassToInstanceMap<Action> map = MutableClassToInstanceMap.create();
+        assertTrue(map.isEmpty());
+    }
+
+    @Test
+    public void whenOfWithParameterCalled_thenCreateSingleEntryMap() {
+        ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of(Save.class, new Save());
+        assertEquals(1, map.size());
+    }
+
+    @Test
+    public void whenBuilderUser_thenCreateMap() {
+        ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.<Action>builder()
+                .put(Save.class, new Save())
+                .put(Open.class, new Open())
+                .build();
+        assertEquals(2, map.size());
+    }
+
+    @Test
+    public void givenClassToInstanceMap_whenGetCalled_returnUpperBoundElement() {
+        ClassToInstanceMap<Action> map = ImmutableClassToInstanceMap.of(Save.class, new Save());
+        Action action = map.get(Save.class);
+        assertTrue(action instanceof Save);
+
+        // Use getInstance to avoid casting
+        Save save = map.getInstance(Save.class);
+    }
+
+    @Test
+    public void givenClassToInstanceMap_whenPutCalled_returnPreviousElementUpperBound() {
+        ClassToInstanceMap<Action> map = MutableClassToInstanceMap.create();
+        map.put(Save.class, new Save());
+        // Put again to get previous value returned
+        Action action = map.put(Save.class, new Save());
+        assertTrue(action instanceof Save);
+
+        // Use putInstance to avoid casting
+        Save save = map.putInstance(Save.class, new Save());
+    }
+}
+
+abstract class Action {
+}
+
+class Save extends Action {
+}
+
+class Open extends Action {
+}
+
+class Delete extends Action {
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/initializemaps/GuavaMapInitializeUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.guava.initializemaps;
+
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.*;
+
+import java.util.Map;
+import org.junit.Test;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+
+public class GuavaMapInitializeUnitTest {
+
+    @Test
+    public void givenKeyValuesShoudInitializeMap() {
+        Map<String, String> articles = ImmutableMap.of("Title", "My New Article", "Title2", "Second Article");
+        
+        assertThat(articles.get("Title"), equalTo("My New Article"));
+        assertThat(articles.get("Title2"), equalTo("Second Article"));
+
+    }
+    
+    
+    @Test
+    public void givenKeyValuesShouldCreateMutableMap() {
+        Map<String, String> articles = Maps.newHashMap(ImmutableMap.of("Title", "My New Article", "Title2", "Second Article"));
+
+        assertThat(articles.get("Title"), equalTo("My New Article"));
+        assertThat(articles.get("Title2"), equalTo("Second Article"));
+    }   
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/mapmaker/GuavaMapMakerUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.guava.mapmaker;
+
+import com.google.common.collect.MapMaker;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ConcurrentMap;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertNotNull;
+
+public class GuavaMapMakerUnitTest {
+    @Test
+    public void whenCreateCaches_thenCreated() {
+        ConcurrentMap<User, Session> sessionCache = new MapMaker().makeMap();
+        assertNotNull(sessionCache);
+
+        ConcurrentMap<User, Profile> profileCache = new MapMaker().makeMap();
+        assertNotNull(profileCache);
+
+        User userA = new User(1, "UserA");
+
+        sessionCache.put(userA, new Session(100));
+        Assert.assertThat(sessionCache.size(), equalTo(1));
+
+        profileCache.put(userA, new Profile(1000, "Personal"));
+        Assert.assertThat(profileCache.size(), equalTo(1));
+    }
+
+    @Test
+    public void whenCreateCacheWithInitialCapacity_thenCreated() {
+        ConcurrentMap<User, Profile> profileCache = new MapMaker().initialCapacity(100).makeMap();
+        assertNotNull(profileCache);
+    }
+
+    @Test
+    public void whenCreateCacheWithConcurrencyLevel_thenCreated() {
+        ConcurrentMap<User, Session> sessionCache = new MapMaker().concurrencyLevel(10).makeMap();
+        assertNotNull(sessionCache);
+    }
+
+    @Test
+    public void whenCreateCacheWithWeakKeys_thenCreated() {
+        ConcurrentMap<User, Session> sessionCache = new MapMaker().weakKeys().makeMap();
+        assertNotNull(sessionCache);
+    }
+
+    @Test
+    public void whenCreateCacheWithWeakValues_thenCreated() {
+        ConcurrentMap<User, Profile> profileCache = new MapMaker().weakValues().makeMap();
+        assertNotNull(profileCache);
+    }
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/maps/GuavaMapsUnitTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.guava.maps;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Test;
+
+import com.google.common.base.Function;
+import com.google.common.collect.*;
+
+public class GuavaMapsUnitTest {
+
+    @Test
+    public void whenCreateImmutableMap_thenCreated() {
+        final Map<String, Integer> salary = ImmutableMap.<String, Integer> builder().put("John", 1000).put("Jane", 1500).put("Adam", 2000).put("Tom", 2000).build();
+
+        assertEquals(1000, salary.get("John").intValue());
+        assertEquals(2000, salary.get("Tom").intValue());
+    }
+
+    @Test
+    public void whenUseSortedMap_thenKeysAreSorted() {
+        final ImmutableSortedMap<String, Integer> salary = new ImmutableSortedMap.Builder<String, Integer>(Ordering.natural()).put("John", 1000).put("Jane", 1500).put("Adam", 2000).put("Tom", 2000).build();
+
+        assertEquals("Adam", salary.firstKey());
+        assertEquals(2000, salary.lastEntry().getValue().intValue());
+    }
+
+    @Test
+    public void whenCreateBiMap_thenCreated() {
+        final BiMap<String, Integer> words = HashBiMap.create();
+        words.put("First", 1);
+        words.put("Second", 2);
+        words.put("Third", 3);
+
+        assertEquals(2, words.get("Second").intValue());
+        assertEquals("Third", words.inverse().get(3));
+    }
+
+    @Test
+    public void whenCreateMultimap_thenCreated() {
+        final Multimap<String, String> multimap = ArrayListMultimap.create();
+        multimap.put("fruit", "apple");
+        multimap.put("fruit", "banana");
+        multimap.put("pet", "cat");
+        multimap.put("pet", "dog");
+
+        assertThat(multimap.get("fruit"), containsInAnyOrder("apple", "banana"));
+        assertThat(multimap.get("pet"), containsInAnyOrder("cat", "dog"));
+    }
+
+    @Test
+    public void whenGroupListUsingMultimap_thenGrouped() {
+        final List<String> names = Lists.newArrayList("John", "Adam", "Tom");
+        final Function<String, Integer> function = new Function<String, Integer>() {
+            @Override
+            public final Integer apply(final String input) {
+                return input.length();
+            }
+        };
+        final Multimap<Integer, String> groups = Multimaps.index(names, function);
+
+        assertThat(groups.get(3), containsInAnyOrder("Tom"));
+        assertThat(groups.get(4), containsInAnyOrder("John", "Adam"));
+    }
+
+    @Test
+    public void whenCreateTable_thenCreated() {
+        final Table<String, String, Integer> distance = HashBasedTable.create();
+        distance.put("London", "Paris", 340);
+        distance.put("New York", "Los Angeles", 3940);
+        distance.put("London", "New York", 5576);
+
+        assertEquals(3940, distance.get("New York", "Los Angeles").intValue());
+        assertThat(distance.columnKeySet(), containsInAnyOrder("Paris", "New York", "Los Angeles"));
+        assertThat(distance.rowKeySet(), containsInAnyOrder("London", "New York"));
+    }
+
+    @Test
+    public void whenTransposeTable_thenCorrect() {
+        final Table<String, String, Integer> distance = HashBasedTable.create();
+        distance.put("London", "Paris", 340);
+        distance.put("New York", "Los Angeles", 3940);
+        distance.put("London", "New York", 5576);
+
+        final Table<String, String, Integer> transposed = Tables.transpose(distance);
+        assertThat(transposed.rowKeySet(), containsInAnyOrder("Paris", "New York", "Los Angeles"));
+        assertThat(transposed.columnKeySet(), containsInAnyOrder("London", "New York"));
+    }
+
+    @Test
+    public void whenCreateClassToInstanceMap_thenCreated() {
+        final ClassToInstanceMap<Number> numbers = MutableClassToInstanceMap.create();
+        numbers.putInstance(Integer.class, 1);
+        numbers.putInstance(Double.class, 1.5);
+
+        assertEquals(1, numbers.get(Integer.class));
+        assertEquals(1.5, numbers.get(Double.class));
+    }
+
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/multimap/GuavaMultiMapUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.guava.multimap;
+
+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 GuavaMultiMapUnitTest {
+
+    @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());
+    }
+}

guava-modules/guava-collections-map/src/test/java/com/baeldung/guava/rangemap/GuavaRangeMapUnitTest.java

@@ -0,0 +1,132 @@
+package com.baeldung.guava.rangemap;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+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 GuavaRangeMapUnitTest {
+
+    @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));
+        assertTrue(experiencedSubRangeDesignationMap.asMapOfRanges().values()
+            .containsAll(Arrays.asList("Executive Director", "Vice President", "Executive Director")));
+        
+    }
+
+    @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();
+
+    }
+}