[BAEL-2664] Groovy collections find

core-groovy/src/main/groovy/com/baeldung/Person.groovy

@@ -0,0 +1,37 @@
+package com.baeldung
+
+class Person {
+    private String firstname
+    private String lastname
+    private Integer age
+
+    Person(String firstname, String lastname, Integer age) {
+        this.firstname = firstname
+        this.lastname = lastname
+        this.age = age
+    }
+
+    String getFirstname() {
+        return firstname
+    }
+
+    void setFirstname(String firstname) {
+        this.firstname = firstname
+    }
+
+    String getLastname() {
+        return lastname
+    }
+
+    void setLastname(String lastname) {
+        this.lastname = lastname
+    }
+
+    Integer getAge() {
+        return age
+    }
+
+    void setAge(Integer age) {
+        this.age = age
+    }
+}

core-groovy/src/test/groovy/com/baeldung/lists/ListTest.groovy

@@ -129,13 +129,13 @@ class ListTest{
         assertTrue(filterList.findAll{it > 3} == [4, 5, 6, 76])
 
         assertTrue(filterList.findAll{ it instanceof Number} == [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep( Number )== [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep{ it> 6 }== [76])
 
         def conditionList = [2, 1, 3, 4, 5, 6, 76]
-        
+
         assertFalse(conditionList.every{ it < 6})
 
         assertTrue(conditionList.any{ it%2 == 0})
@@ -165,7 +165,7 @@ class ListTest{
 
         def strList = ["na", "ppp", "as"]
         assertTrue(strList.max() == "ppp")
-        
+
         Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1}
         def numberList = [3, 2, 0, 7]
         assertTrue(numberList.min(minc) == 0)

core-groovy/src/test/groovy/com/baeldung/lists/ListUnitTest.groovy

@@ -0,0 +1,58 @@
+package com.baeldung.lists
+
+import com.baeldung.Person
+import org.junit.Test
+
+import static org.junit.Assert.*
+
+class ListUnitTest {
+
+    private final personList = [
+      new Person("Regina", "Fitzpatrick", 25),
+      new Person("Abagail", "Ballard", 26),
+      new Person("Lucian", "Walter", 30),
+    ]
+
+    @Test
+    void whenListContainsElement_thenCheckReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue(list.indexOf('a') > -1)
+        assertTrue(list.contains('a'))
+    }
+
+    @Test
+    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue('a' in list)
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
+        assertTrue(personList.stream().anyMatch {it.age > 20})
+        assertFalse(personList.stream().allMatch {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
+        assertTrue(personList.any {it.age > 20})
+        assertFalse(personList.every {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements() {
+        assertTrue(personList.stream().filter {it.age > 20}.findAny().isPresent())
+        assertFalse(personList.stream().filter {it.age > 30}.findAny().isPresent())
+        assertTrue(personList.stream().filter {it.age > 20}.findAll().size() == 3)
+        assertTrue(personList.stream().filter {it.age > 30}.findAll().isEmpty())
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements() {
+        assertNotNull(personList.find {it.age > 20})
+        assertNull(personList.find {it.age > 30})
+        assertTrue(personList.findAll {it.age > 20}.size() == 3)
+        assertTrue(personList.findAll {it.age > 30}.isEmpty())
+    }
+}

core-groovy/src/test/groovy/com/baeldung/map/MapUnitTest.groovy

@@ -1,10 +1,18 @@
 package com.baeldung.map
 
-import static org.junit.Assert.*
+import com.baeldung.Person
 import org.junit.Test
 
+import static org.junit.Assert.*
+
 class MapUnitTest {
 
+    private final personMap = [
+      Regina : new Person("Regina", "Fitzpatrick", 25),
+      Abagail: new Person("Abagail", "Ballard", 26),
+      Lucian : new Person("Lucian", "Walter", 30)
+    ]
+
     @Test
     void whenUsingEach_thenMapIsIterated() {
         def map = [
@@ -63,7 +71,7 @@ class MapUnitTest {
             'FF6347' : 'Tomato',
             'FF4500' : 'Orange Red'
         ]
-        
+
         map.eachWithIndex { key, val, index ->
             def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
             println "$indent Hex Code: $key = Color Name: $val"
@@ -82,4 +90,65 @@ class MapUnitTest {
             println "Hex Code: $entry.key = Color Name: $entry.value"
         }
     }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue(map.containsKey('a'))
+        assertFalse(map.containsKey('e'))
+        assertTrue(map.containsValue('e'))
+    }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue('a' in map)
+        assertFalse('f' in map)
+    }
+
+    @Test
+    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+        def map = [a: true, b: false, c: null]
+
+        assertTrue(map.containsKey('b'))
+        assertTrue('a' in map)
+        assertFalse('b' in map)
+        assertFalse('c' in map)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().stream().anyMatch {it == "Regina"})
+        assertFalse(personMap.keySet().stream().allMatch {it == "Albert"})
+        assertFalse(personMap.values().stream().allMatch {it.age < 30})
+        assertTrue(personMap.entrySet().stream().anyMatch {it.key == "Abagail" && it.value.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().any {it == "Regina"})
+        assertFalse(personMap.keySet().every {it == "Albert"})
+        assertFalse(personMap.values().every {it.age < 30})
+        assertTrue(personMap.any {firstname, person -> firstname == "Abagail" && person.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements() {
+        assertNotNull(personMap.find {it.key == "Abagail" && it.value.lastname == "Ballard"})
+        assertTrue(personMap.findAll {it.value.age > 20}.size() == 3)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements() {
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.key == "Abagail" && it.value.lastname == "Ballard"}
+            .findAny().isPresent())
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.value.age > 20}
+            .findAll().size() == 3)
+    }
 }

core-groovy/src/test/groovy/com/baeldung/set/SetUnitTest.groovy

@@ -0,0 +1,16 @@
+package com.baeldung.set
+
+import org.junit.Test
+
+import static org.junit.Assert.assertTrue
+
+class SetUnitTest {
+
+    @Test
+    void whenSetContainsElement_thenCheckReturnsTrue() {
+        def set = ['a', 'b', 'c'] as Set
+
+        assertTrue(set.contains('a'))
+        assertTrue('a' in set)
+    }
+}