Merge pull request #13317 from Alex-Golub/study-groovy

Groovy module improvements

core-groovy-modules/core-groovy-2/pom.xml

@@ -155,8 +155,9 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
@@ -167,4 +168,4 @@
         <groovy.compiler.version>3.3.0-01</groovy.compiler.version>
     </properties>
 
-</project>
+</project>

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/category/BaeldungCategory.groovy

@@ -1,17 +1,17 @@
-package com.baeldung.category;
+package com.baeldung.category
 
 class BaeldungCategory {
 
-    public static String capitalize(String self) {
-        String capitalizedStr = self;
+    static String capitalize(String self) {
+        String capitalizedStr = self
         if (self.size() > 0) {
-            capitalizedStr = self.substring(0, 1).toUpperCase() + self.substring(1);
+            capitalizedStr = self.substring(0, 1).toUpperCase() + self.substring(1)
         }
+        
         return capitalizedStr
     }
-    
-    public static double toThePower(Number self, Number exponent) {
-        return Math.pow(self, exponent);
-    }
 
+    static double toThePower(Number self, Number exponent) {
+        return Math.pow(self, exponent)
+    }
 }

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/category/NumberCategory.groovy

@@ -1,17 +1,15 @@
-package com.baeldung.category;
-
-import groovy.lang.Category
+package com.baeldung.category
 
 @Category(Number)
 class NumberCategory {
 
-    public Number cube() {
-        return this*this*this
+    Number cube() {
+        return this**3
     }
 
-    public int divideWithRoundUp(BigDecimal divisor, boolean isRoundUp) {
+    int divideWithRoundUp(BigDecimal divisor, boolean isRoundUp) {
         def mathRound = isRoundUp ? BigDecimal.ROUND_UP : BigDecimal.ROUND_DOWN
-        return (int)new BigDecimal(this).divide(divisor, 0, mathRound)
+        
+        return (int) new BigDecimal(this).divide(divisor, 0, mathRound)
     }
-
 }

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/determinedatatype/Person.groovy

@@ -1,14 +1,19 @@
 package com.baeldung.determinedatatype
 
 class Person {
-    
-    private int ageAsInt
-    private Double ageAsDouble
-    private String ageAsString
-    
+
+    int ageAsInt
+    Double ageAsDouble
+    String ageAsString
+
     Person() {}
-    Person(int ageAsInt) { this.ageAsInt =  ageAsInt}
-    Person(Double ageAsDouble) { this.ageAsDouble =  ageAsDouble}
-    Person(String ageAsString) { this.ageAsString =  ageAsString}    
+
+    Person(int ageAsInt) { this.ageAsInt = ageAsInt }
+
+    Person(Double ageAsDouble) { this.ageAsDouble = ageAsDouble }
+
+    Person(String ageAsString) { this.ageAsString = ageAsString }
+}
+
+class Student extends Person {
 }
-class Student extends Person {}

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/metaprogramming/Employee.groovy

@@ -1,18 +1,14 @@
 package com.baeldung.metaprogramming
 
-import groovy.transform.AutoClone
-import groovy.transform.Canonical
-import groovy.transform.EqualsAndHashCode
-import groovy.transform.ToString
-import groovy.transform.TupleConstructor
-import groovy.util.logging.*
+import groovy.transform.*
+import groovy.util.logging.Log
 
-@Canonical
+@ToString(includePackage = false, excludes = ['id'])
 @TupleConstructor
 @EqualsAndHashCode
-@ToString(includePackage=false, excludes=['id'])
-@Log 
-@AutoClone
+@Canonical
+@AutoClone(style = AutoCloneStyle.SIMPLE)
+@Log
 class Employee {
 
     long id
@@ -30,16 +26,15 @@ class Employee {
     def propertyMissing(String propertyName, propertyValue) {
         println "property '$propertyName' is not available"
         log.info "$propertyName is not available"
-        "property '$propertyName' is not available"
+        "property '$propertyName' with value '$propertyValue' is not available"
     }
 
-    def methodMissing(String methodName, def methodArgs) {
+    def methodMissing(String methodName, Object methodArgs) {
         log.info "$methodName is not defined"
         "method '$methodName' is not defined"
     }
-    
+
     def logEmp() {
         log.info "Employee: $lastName, $firstName is of $age years age"
     }
-
-}
+}

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/metaprogramming/extension/BasicExtensions.groovy

@@ -2,32 +2,31 @@ package com.baeldung.metaprogramming.extension
 
 import com.baeldung.metaprogramming.Employee
 
-import java.time.LocalDate
 import java.time.Year
 
 class BasicExtensions {
-    
+
     static int getYearOfBirth(Employee self) {
         return Year.now().value - self.age
     }
-    
+
     static String capitalize(String self) {
         return self.substring(0, 1).toUpperCase() + self.substring(1)
     }
 
     static void printCounter(Integer self) {
-        while (self>0) {
+        while (self > 0) {
             println self
             self--
         }
     }
-    
+
     static Long square(Long self) {
-        return self*self
+        return self * self
     }
-    
+
     static BigDecimal cube(BigDecimal self) {
-        return self*self*self
+        return self * self * self
     }
-    
-}
+
+}

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/category/CategoryUnitTest.groovy

@@ -1,17 +1,17 @@
 package com.baeldung.category
 
-import groovy.time.*
+import groovy.time.TimeCategory
+import groovy.xml.DOMBuilder
+import groovy.xml.QName
+import groovy.xml.dom.DOMCategory
+
 import java.text.SimpleDateFormat
-import groovy.xml.*
-import groovy.xml.dom.*
-import com.baeldung.category.BaeldungCategory
-import com.baeldung.category.NumberCategory
 
 class CategoryUnitTest extends GroovyTestCase {
 
     void test_whenUsingTimeCategory_thenOperationOnDate() {
         def jan_1_2019 = new Date("01/01/2019")
-        use (TimeCategory) {
+        use(TimeCategory) {
             assert jan_1_2019 + 10.seconds == new Date("01/01/2019 00:00:10")
 
             assert jan_1_2019 + 20.minutes == new Date("01/01/2019 00:20:00")
@@ -30,7 +30,7 @@ class CategoryUnitTest extends GroovyTestCase {
 
     void test_whenUsingTimeCategory_thenOperationOnNumber() {
         SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
-        use (TimeCategory) {
+        use(TimeCategory) {
             assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
 
             sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
@@ -57,7 +57,7 @@ class CategoryUnitTest extends GroovyTestCase {
 
         def root = baeldungArticlesDom.documentElement
 
-        use (DOMCategory) {
+        use(DOMCategory) {
             assert root.article.size() == 2
 
             def articles = root.article
@@ -75,27 +75,26 @@ class CategoryUnitTest extends GroovyTestCase {
             assert root.article[2].title.text() == "Metaprogramming in Groovy"
         }
     }
-    
+
     void test_whenUsingBaeldungCategory_thenCapitalizeString() {
-        use (BaeldungCategory) {
+        use(BaeldungCategory) {
             assert "norman".capitalize() == "Norman"
-        } 
+        }
     }
-    
+
     void test_whenUsingBaeldungCategory_thenOperationsOnNumber() {
-        use (BaeldungCategory) {
+        use(BaeldungCategory) {
             assert 50.toThePower(2) == 2500
             assert 2.4.toThePower(4) == 33.1776
         }
     }
-    
+
     void test_whenUsingNumberCategory_thenOperationsOnNumber() {
-        use (NumberCategory) {
+        use(NumberCategory) {
             assert 3.cube() == 27
             assert 25.divideWithRoundUp(6, true) == 5
             assert 120.23.divideWithRoundUp(6.1, true) == 20
             assert 150.9.divideWithRoundUp(12.1, false) == 12
         }
     }
-
 }

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/determinedatatype/PersonTest.groovy

@@ -1,56 +1,68 @@
 package com.baeldung.determinedatatype
 
-import org.junit.Assert
-import org.junit.Test
-import com.baeldung.determinedatatype.Person
+import spock.lang.Specification
 
-public class PersonTest {
-    
-    @Test
-    public void givenWhenParameterTypeIsInteger_thenReturnTrue() {
+class PersonTest extends Specification {
+
+    def "givenWhenParameterTypeIsIntegerThenReturnTrue"() {
+        given:
         Person personObj = new Person(10)
-        Assert.assertTrue(personObj.ageAsInt instanceof Integer)
-    }
-    
-    @Test
-    public void givenWhenParameterTypeIsDouble_thenReturnTrue() {
-        Person personObj = new Person(10.0)
-        Assert.assertTrue((personObj.ageAsDouble).getClass() == Double)
-    }
-    
-    @Test
-    public void givenWhenParameterTypeIsString_thenReturnTrue() {
-        Person personObj = new Person("10 years")
-        Assert.assertTrue(personObj.ageAsString.class == String)
-    }
-    
-    @Test
-    public void givenClassName_WhenParameterIsInteger_thenReturnTrue() {
-        Assert.assertTrue(Person.class.getDeclaredField('ageAsInt').type == int.class)
-    }
-    
-    @Test
-    public void givenWhenObjectIsInstanceOfType_thenReturnTrue() {
-        Person personObj = new Person()
-        Assert.assertTrue(personObj instanceof Person)
+
+        expect:
+        personObj.ageAsInt.class == Integer
     }
 
-    @Test
-    public void givenWhenInstanceIsOfSubtype_thenReturnTrue() {
+    def "givenWhenParameterTypeIsDouble_thenReturnTrue"() {
+        given:
+        Person personObj = new Person(10.0)
+
+        expect:
+        personObj.ageAsDouble.class == Double
+    }
+
+    def "givenWhenParameterTypeIsString_thenReturnTrue"() {
+        given:
+        Person personObj = new Person("10 years")
+
+        expect:
+        personObj.ageAsString.class == String
+    }
+
+    def "givenClassName_WhenParameterIsInteger_thenReturnTrue"() {
+        expect:
+        Person.class.getDeclaredField('ageAsInt').type == int.class
+    }
+
+    def "givenWhenObjectIsInstanceOfType_thenReturnTrue"() {
+        given:
+        Person personObj = new Person()
+
+        expect:
+        personObj.class == Person
+    }
+
+    def "givenWhenInstanceIsOfSubtype_thenReturnTrue"() {
+        given:
         Student studentObj = new Student()
-        Assert.assertTrue(studentObj in Person)
+
+        expect:
+        studentObj.class.superclass == Person
     }
-    
-    @Test
-    public void givenGroovyList_WhenFindClassName_thenReturnTrue() {
-      def ageList = ['ageAsString','ageAsDouble', 10]   
-      Assert.assertTrue(ageList.class == ArrayList)     
-      Assert.assertTrue(ageList.getClass() == ArrayList)
+
+    def "givenGroovyList_WhenFindClassName_thenReturnTrue"() {
+        given:
+        def ageList = ['ageAsString', 'ageAsDouble', 10]
+
+        expect:
+        ageList.class == ArrayList
+        ageList.getClass() == ArrayList
     }
-    
-    @Test
-    public void givenGrooyMap_WhenFindClassName_thenReturnTrue() {
-      def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
-      Assert.assertFalse(ageMap.class == LinkedHashMap)
+
+    def "givenGroovyMap_WhenFindClassName_thenReturnTrue"() {
+        given:
+        def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
+
+        expect:
+        ageMap.getClass() == LinkedHashMap
     }
-}
+}

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/metaprogramming/MetaprogrammingUnitTest.groovy

@@ -1,123 +1,163 @@
 package com.baeldung.metaprogramming
 
+import spock.lang.Specification
 
-import java.time.LocalDate
-import java.time.Period
 import java.time.Year
 
-class MetaprogrammingUnitTest extends GroovyTestCase {
+class MetaprogrammingUnitTest extends Specification {
 
-    Employee emp = new Employee(firstName: "Norman", lastName: "Lewis")
+    Employee emp
 
-    void testPropertyMissing() {
-        assert emp.address == "property 'address' is not available"
+    void setup() {
+        emp = new Employee(firstName: "Norman", lastName: "Lewis")
     }
 
-    void testMethodMissing() {
+    def "testPropertyMissing"() {
+        expect:
+        emp.address == "property 'address' is not available"
+    }
+
+    def "testMethodMissing"() {
+        given:
         Employee emp = new Employee()
-        try {
-            emp.getFullName()
-        } catch(MissingMethodException e) {
-            println "method is not defined"
-        }
-        assert emp.getFullName() == "method 'getFullName' is not defined"
+
+        expect:
+        emp.getFullName() == "method 'getFullName' is not defined"
     }
 
-    void testMetaClassProperty() {
+    def "testMetaClassProperty"() {
+        when:
         Employee.metaClass.address = ""
-        emp = new Employee(firstName: "Norman", lastName: "Lewis", address: "US")
-        assert emp.address == "US"
+
+        and:
+        emp = new Employee(firstName: "Norman",
+                           lastName: "Lewis",
+                           address: "US")
+
+        then:
+        emp.address == "US"
     }
 
-    void testMetaClassMethod() {
+    def "testMetaClassMethod"() {
+        when:
         emp.metaClass.getFullName = {
             "$lastName, $firstName"
         }
-        assert emp.getFullName() == "Lewis, Norman"
+
+        then:
+        emp.getFullName() == "Lewis, Norman"
     }
 
-    void testMetaClassConstructor() {
-        try {
-            Employee emp = new Employee("Norman")
-        } catch(GroovyRuntimeException e) {
-            assert e.message == "Could not find matching constructor for: com.baeldung.metaprogramming.Employee(String)"
-        }
+    def "testOnlyNameConstructor"() {
+        when:
+        new Employee("Norman")
 
+        then:
+        thrown(GroovyRuntimeException)
+    }
+
+    def "testMetaClassConstructor"() {
+        when:
         Employee.metaClass.constructor = { String firstName ->
             new Employee(firstName: firstName)
         }
 
+        and:
         Employee norman = new Employee("Norman")
-        assert norman.firstName == "Norman"
-        assert norman.lastName == null
+
+        then:
+        norman.firstName == "Norman"
+        norman.lastName == null
     }
 
-    void testJavaMetaClass() {
+    def "testJavaMetaClass"() {
+        when:
         String.metaClass.capitalize = { String str ->
             str.substring(0, 1).toUpperCase() + str.substring(1)
         }
-        assert "norman".capitalize() == "Norman"
+
+        and:
+        String.metaClass.static.joinWith = { String delimiter, String... args ->
+            String.join(delimiter, args)
+        }
+
+        then:
+        "norman".capitalize() == "Norman"
+        String.joinWith(" -> ", "a", "b", "c") == "a -> b -> c"
     }
 
-    void testEmployeeExtension() {
+    def "testEmployeeExtension"() {
+        given:
         def age = 28
         def expectedYearOfBirth = Year.now() - age
         Employee emp = new Employee(age: age)
-        assert emp.getYearOfBirth() == expectedYearOfBirth.value
+
+        expect:
+        emp.getYearOfBirth() == expectedYearOfBirth.value
     }
 
-    void testJavaClassesExtensions() {
+    def "testJavaClassesExtensions"() {
+        when:
         5.printCounter()
 
-        assert 40l.square() == 1600l
-
-        assert (2.98).cube() == 26.463592
+        then:
+        40L.square() == 1600L
+        (2.98).cube() == 26.463592
     }
 
-    void testStaticEmployeeExtension() {
+    def "testStaticEmployeeExtension"() {
         assert Employee.getDefaultObj().firstName == "firstName"
         assert Employee.getDefaultObj().lastName == "lastName"
         assert Employee.getDefaultObj().age == 20
     }
 
-    void testToStringAnnotation() {
-        Employee employee = new Employee()
-        employee.id = 1
-        employee.firstName = "norman"
-        employee.lastName = "lewis"
-        employee.age = 28
+    def "testToStringAnnotation"() {
+        when:
+        Employee employee = new Employee().tap {
+            id = 1
+            firstName = "norman"
+            lastName = "lewis"
+            age = 28
+        }
 
-        assert employee.toString() == "Employee(norman, lewis, 28)"
+        then:
+        employee.toString() == "Employee(norman, lewis, 28)"
     }
 
-    void testTupleConstructorAnnotation() {
+    def "testTupleConstructorAnnotation"() {
+        when:
         Employee norman = new Employee(1, "norman", "lewis", 28)
-        assert norman.toString() == "Employee(norman, lewis, 28)"
-
         Employee snape = new Employee(2, "snape")
-        assert snape.toString() == "Employee(snape, null, 0)"
 
+        then:
+        norman.toString() == "Employee(norman, lewis, 28)"
+        snape.toString() == "Employee(snape, null, 0)"
     }
-    
-    void testEqualsAndHashCodeAnnotation() {
+
+    def "testEqualsAndHashCodeAnnotation"() {
+        when:
         Employee norman = new Employee(1, "norman", "lewis", 28)
         Employee normanCopy = new Employee(1, "norman", "lewis", 28)
-        assert norman.equals(normanCopy)
-        assert norman.hashCode() == normanCopy.hashCode()
-    }
-    
-    void testAutoCloneAnnotation() {
-        try {
-            Employee norman = new Employee(1, "norman", "lewis", 28)
-            def normanCopy = norman.clone()
-            assert norman == normanCopy
-        } catch(CloneNotSupportedException e) {
-            e.printStackTrace()
-        }
+
+        then:
+        norman == normanCopy
+        norman.hashCode() == normanCopy.hashCode()
     }
 
-    void testLoggingAnnotation() {
+    def "testAutoCloneAnnotation"() {
+        given:
+        Employee norman = new Employee(1, "norman", "lewis", 28)
+
+        when:
+        def normanCopy = norman.clone()
+
+        then:
+        norman == normanCopy
+    }
+
+    def "testLoggingAnnotation"() {
+        given:
         Employee employee = new Employee(1, "Norman", "Lewis", 28)
-        employee.logEmp()
+        employee.logEmp() // INFO: Employee: Lewis, Norman is of 28 years age
     }
 }

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/templateengine/TemplateEnginesUnitTest.groovy

@@ -1,48 +1,62 @@
 package com.baeldung.templateengine
 
+import groovy.text.GStringTemplateEngine
 import groovy.text.SimpleTemplateEngine
 import groovy.text.StreamingTemplateEngine
-import groovy.text.GStringTemplateEngine
-import groovy.text.XmlTemplateEngine
 import groovy.text.XmlTemplateEngine
 import groovy.text.markup.MarkupTemplateEngine
 import groovy.text.markup.TemplateConfiguration
+import spock.lang.Specification
 
-class TemplateEnginesUnitTest extends GroovyTestCase {
-    
-    def bindMap = [user: "Norman", signature: "Baeldung"]
-    
-    void testSimpleTemplateEngine() {
+class TemplateEnginesUnitTest extends Specification {
+
+    final Map BIND_MAP = [user: "Norman", signature: "Baeldung"]
+
+    def "testSimpleTemplateEngine"() {
+        given:
         def smsTemplate = 'Dear <% print user %>, Thanks for reading our Article. ${signature}'
-        def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(bindMap)
 
-        assert smsText.toString() == "Dear Norman, Thanks for reading our Article. Baeldung"
+        when:
+        def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(BIND_MAP)
+
+        then:
+        smsText.toString() == "Dear Norman, Thanks for reading our Article. Baeldung"
     }
-    
-    void testStreamingTemplateEngine() {
+
+    def "testStreamingTemplateEngine"() {
+        given:
         def articleEmailTemplate = new File('src/main/resources/articleEmail.template')
-        bindMap.articleText = """1. Overview
-This is a tutorial article on Template Engines""" //can be a string larger than 64k
-        
-        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(bindMap)
-        
-        assert articleEmailText.toString() == """Dear Norman,
-Please read the requested article below.
-1. Overview
-This is a tutorial article on Template Engines
-From,
-Baeldung"""
-        
+        //can be a string larger than 64k
+        BIND_MAP.articleText = """|1. Overview
+                                  |This is a tutorial article on Template Engines""".stripMargin()
+
+        when:
+        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(BIND_MAP)
+
+        then:
+        articleEmailText.toString() == """|Dear Norman,
+                                          |Please read the requested article below.
+                                          |1. Overview
+                                          |This is a tutorial article on Template Engines
+                                          |From,
+                                          |Baeldung""".stripMargin()
     }
-    
-    void testGStringTemplateEngine() {
+
+    def "testGStringTemplateEngine"() {
+        given:
         def emailTemplate = new File('src/main/resources/email.template')
-        def emailText = new GStringTemplateEngine().createTemplate(emailTemplate).make(bindMap)
-        
-        assert emailText.toString() == "Dear Norman,\nThanks for subscribing our services.\nBaeldung"
+
+        when:
+        def emailText = new GStringTemplateEngine().createTemplate(emailTemplate).make(BIND_MAP)
+
+        then:
+        emailText.toString() == """|Dear Norman,
+                                   |Thanks for subscribing our services.
+                                   |Baeldung""".stripMargin()
     }
-    
-    void testXmlTemplateEngine() {
+
+    def "testXmlTemplateEngine"() {
+        given:
         def emailXmlTemplate = '''<xs xmlns:gsp='groovy-server-pages'>
                                       <gsp:scriptlet>def emailContent = "Thanks for subscribing our services."</gsp:scriptlet>
                                       <email>
@@ -51,11 +65,16 @@ Baeldung"""
                                           <signature>${signature}</signature>
                                       </email>
                                   </xs>'''
-        def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(bindMap)
+
+        when:
+        def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(BIND_MAP)
+
+        then:
         println emailXml.toString()
     }
-    
-    void testMarkupTemplateEngineHtml() {
+
+    def "testMarkupTemplateEngineHtml"() {
+        given:
         def emailHtmlTemplate = """html {
                                        head {
                                            title('Service Subscription Email')
@@ -66,14 +85,16 @@ Baeldung"""
                                            p('Baeldung')
                                        }
                                    }"""
-        
-        
+
+        when:
         def emailHtml = new MarkupTemplateEngine().createTemplate(emailHtmlTemplate).make()
+
+        then:
         println emailHtml.toString()
-        
     }
-    
-    void testMarkupTemplateEngineXml() {
+
+    def "testMarkupTemplateEngineXml"() {
+        given:
         def emailXmlTemplate = """xmlDeclaration()  
                                       xs{
                                           email {
@@ -83,14 +104,18 @@ Baeldung"""
                                           }  
                                       }
                                """
-        TemplateConfiguration config = new TemplateConfiguration()
-        config.autoIndent = true
-        config.autoEscape = true
-        config.autoNewLine = true
+        TemplateConfiguration config = new TemplateConfiguration().with {
+            autoIndent = true
+            autoEscape = true
+            autoNewLine = true
 
+            return it
+        }
+
+        when:
         def emailXml = new MarkupTemplateEngine(config).createTemplate(emailXmlTemplate).make()
-        
+
+        then:
         println emailXml.toString()
     }
-    
-}
+}

core-groovy-modules/core-groovy-collections/pom.xml

@@ -113,9 +113,11 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>http://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+
+</project>

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/ListFindUnitTest.groovy

@@ -1,58 +1,57 @@
 package com.baeldung.find
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class ListFindUnitTest extends Specification {
 
-class ListFindUnitTest {
-
-    private final personList = [
-      new Person("Regina", "Fitzpatrick", 25),
-      new Person("Abagail", "Ballard", 26),
-      new Person("Lucian", "Walter", 30),
+    final personList = [
+            new Person("Regina", "Fitzpatrick", 25),
+            new Person("Abagail", "Ballard", 26),
+            new Person("Lucian", "Walter", 30),
     ]
 
-    @Test
-    void whenListContainsElement_thenCheckReturnsTrue() {
+    def "whenListContainsElement_thenCheckReturnsTrue"() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue(list.indexOf('a') > -1)
-        assertTrue(list.contains('a'))
+        expect:
+        list.indexOf('a') > -1
+        list.contains('a')
     }
 
-    @Test
-    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+    def "whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue"() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue('a' in list)
+        expect:
+        'a' in list
     }
 
-    @Test
-    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
-        assertTrue(personList.stream().anyMatch {it.age > 20})
-        assertFalse(personList.stream().allMatch {it.age < 30})
+    def "givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList"() {
+        expect:
+        personList.stream().anyMatch { it.age > 20 }
+        !personList.stream().allMatch { it.age < 30 }
     }
 
-    @Test
-    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
-        assertTrue(personList.any {it.age > 20})
-        assertFalse(personList.every {it.age < 30})
+    def "givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList"() {
+        expect:
+        personList.any { it.age > 20 }
+        !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())
+    def "givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements"() {
+        expect:
+        personList.stream().filter { it.age > 20 }.findAny().isPresent()
+        !personList.stream().filter { it.age > 30 }.findAny().isPresent()
+        personList.stream().filter { it.age > 20 }.findAll().size() == 3
+        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())
+    def "givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements"() {
+        expect:
+        personList.find { it.age > 20 } == new Person("Regina", "Fitzpatrick", 25)
+        personList.find { it.age > 30 } == null
+        personList.findAll { it.age > 20 }.size() == 3
+        personList.findAll { it.age > 30 }.isEmpty()
     }
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/MapFindUnitTest.groovy

@@ -1,76 +1,81 @@
 package com.baeldung.find
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class MapFindUnitTest extends Specification {
 
-class MapFindUnitTest {
-
-    private final personMap = [
-      Regina : new Person("Regina", "Fitzpatrick", 25),
-      Abagail: new Person("Abagail", "Ballard", 26),
-      Lucian : new Person("Lucian", "Walter", 30)
+    final personMap = [
+            Regina: new Person("Regina", "Fitzpatrick", 25),
+            Abagail: new Person("Abagail", "Ballard", 26),
+            Lucian: new Person("Lucian", "Walter", 30)
     ]
 
-    @Test
-    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+    def "whenMapContainsKeyElement_thenCheckReturnsTrue"() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue(map.containsKey('a'))
-        assertFalse(map.containsKey('e'))
-        assertTrue(map.containsValue('e'))
+        expect:
+        map.containsKey('a')
+        !map.containsKey('e')
+        map.containsValue('e')
     }
 
-    @Test
-    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+    def "whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue"() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue('a' in map)
-        assertFalse('f' in map)
+        expect:
+        'a' in map
+        'f' !in map
     }
 
-    @Test
-    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+    def "whenMapContainsFalseBooleanValues_thenCheckReturnsFalse"() {
+        given:
         def map = [a: true, b: false, c: null]
 
-        assertTrue(map.containsKey('b'))
-        assertTrue('a' in map)
-        assertFalse('b' in map)
-        assertFalse('c' in map)
+        expect:
+        map.containsKey('b')
+        'a' in map
+        'b' !in map // get value of key 'b' and does the assertion
+        '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"})
+    def "givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap"() {
+        expect:
+        personMap.keySet().stream()
+                 .anyMatch { it == "Regina" }
+        !personMap.keySet().stream()
+                  .allMatch { it == "Albert" }
+        !personMap.values().stream()
+                  .allMatch { it.age < 30 }
+        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"})
+    def "givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap"() {
+        expect:
+        personMap.keySet().any { it == "Regina" }
+        !personMap.keySet().every { it == "Albert" }
+        !personMap.values().every { it.age < 30 }
+        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)
+    def "givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements"() {
+        expect:
+        personMap.find { it.key == "Abagail" && it.value.lastname == "Ballard" }
+        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)
+    def "givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements"() {
+        expect:
+        personMap.entrySet().stream()
+                 .filter { it.key == "Abagail" && it.value.lastname == "Ballard" }
+                 .findAny()
+                 .isPresent()
+
+        personMap.entrySet().stream()
+                 .filter { it.value.age > 20 }
+                 .findAll()
+                 .size() == 3
     }
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/Person.groovy

@@ -1,37 +1,10 @@
 package com.baeldung.find
 
+import groovy.transform.Canonical
+
+@Canonical
 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
-    }
+    String firstname
+    String lastname
+    Integer age
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/SetFindUnitTest.groovy

@@ -1,16 +1,15 @@
 package com.baeldung.find
 
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.assertTrue
+class SetFindUnitTest extends Specification {
 
-class SetFindUnitTest {
-
-    @Test
-    void whenSetContainsElement_thenCheckReturnsTrue() {
+    def "whenSetContainsElement_thenCheckReturnsTrue"() {
+        given:
         def set = ['a', 'b', 'c'] as Set
 
-        assertTrue(set.contains('a'))
-        assertTrue('a' in set)
+        expect:
+        set.contains('a')
+        'a' in set
     }
-}
+}

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/iteratemap/IterateMapUnitTest.groovy

@@ -1,85 +1,54 @@
 package com.baeldung.iteratemap
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class IterateMapUnitTest extends Specification {
 
-class IterateMapUnitTest {
-
-    @Test
-    void whenUsingEach_thenMapIsIterated() {
-        def map = [
-                'FF0000' : 'Red',
-                '00FF00' : 'Lime',
-                '0000FF' : 'Blue',
-                'FFFF00' : 'Yellow'
-        ]
+    final Map map = [
+            'FF0000': 'Red',
+            '00FF00': 'Lime',
+            '0000FF': 'Blue',
+            'FFFF00': 'Yellow',
+            'E6E6FA': 'Lavender',
+            'D8BFD8': 'Thistle',
+            'DDA0DD': 'Plum',
+    ]
 
+    def "whenUsingEach_thenMapIsIterated"() {
+        expect:
         map.each { println "Hex Code: $it.key = Color Name: $it.value" }
     }
 
-    @Test
-    void whenUsingEachWithEntry_thenMapIsIterated() {
-        def map = [
-                'E6E6FA' : 'Lavender',
-                'D8BFD8' : 'Thistle',
-                'DDA0DD' : 'Plum',
-        ]
-
+    def "whenUsingEachWithEntry_thenMapIsIterated"() {
+        expect:
         map.each { entry -> println "Hex Code: $entry.key = Color Name: $entry.value" }
     }
 
-    @Test
-    void whenUsingEachWithKeyAndValue_thenMapIsIterated() {
-        def map = [
-                '000000' : 'Black',
-                'FFFFFF' : 'White',
-                '808080' : 'Gray'
-        ]
-
+    def "whenUsingEachWithKeyAndValue_thenMapIsIterated"() {
+        expect:
         map.each { key, val ->
             println "Hex Code: $key = Color Name $val"
         }
     }
 
-    @Test
-    void whenUsingEachWithIndexAndEntry_thenMapIsIterated() {
-        def map = [
-                '800080' : 'Purple',
-                '4B0082' : 'Indigo',
-                '6A5ACD' : 'Slate Blue'
-        ]
-
+    def "whenUsingEachWithIndexAndEntry_thenMapIsIterated"() {
+        expect:
         map.eachWithIndex { entry, index ->
-            def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
+            def indent = index % 2 == 0 ? "   " : ""
             println "$indent Hex Code: $entry.key = Color Name: $entry.value"
         }
     }
 
-    @Test
-    void whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated() {
-        def map = [
-                'FFA07A' : 'Light Salmon',
-                'FF7F50' : 'Coral',
-                'FF6347' : 'Tomato',
-                'FF4500' : 'Orange Red'
-        ]
-
+    def "whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated"() {
+        expect:
         map.eachWithIndex { key, val, index ->
-            def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
+            def indent = index % 2 == 0 ? "   " : ""
             println "$indent Hex Code: $key = Color Name: $val"
         }
     }
 
-    @Test
-    void whenUsingForLoop_thenMapIsIterated() {
-        def map = [
-                '2E8B57' : 'Seagreen',
-                '228B22' : 'Forest Green',
-                '008000' : 'Green'
-        ]
-
+    def "whenUsingForLoop_thenMapIsIterated"() {
+        expect:
         for (entry in map) {
             println "Hex Code: $entry.key = Color Name: $entry.value"
         }

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

@@ -1,173 +1,171 @@
 package com.baeldung.lists
 
-import static groovy.test.GroovyAssert.*
-import org.junit.Test
+import spock.lang.Specification
 
-class ListUnitTest {
-
-    @Test
-    void testCreateList() {
+class ListUnitTest extends Specification {
 
+    def "testCreateList"() {
+        when:
         def list = [1, 2, 3]
-        assertNotNull(list)
-
         def listMix = ['A', "b", 1, true]
-        assertTrue(listMix == ['A', "b", 1, true])
-
         def linkedList = [1, 2, 3] as LinkedList
-        assertTrue(linkedList instanceof LinkedList)
-
         ArrayList arrList = [1, 2, 3]
-        assertTrue(arrList.class == ArrayList)
-
         def copyList = new ArrayList(arrList)
-        assertTrue(copyList == arrList)
-
         def cloneList = arrList.clone()
-        assertTrue(cloneList == arrList)
+
+        then:
+        list
+        listMix == ['A', "b", 1, true]
+        linkedList instanceof LinkedList
+        arrList.class == ArrayList
+        copyList == arrList
+        cloneList == arrList
     }
 
-    @Test
-    void testCreateEmptyList() {
-
+    def "testCreateEmptyList"() {
+        when:
         def emptyList = []
-        assertTrue(emptyList.size() == 0)
+
+        then:
+        emptyList.isEmpty()
     }
 
-    @Test
-    void testCompareTwoLists() {
-
+    def "testCompareTwoLists"() {
+        when:
         def list1 = [5, 6.0, 'p']
         def list2 = [5, 6.0, 'p']
-        assertTrue(list1 == list2)
+
+        then:
+        list1 == list2
     }
 
-    @Test
-    void testGetItemsFromList(){
-
+    def "testGetItemsFromList"() {
+        when:
         def list = ["Hello", "World"]
 
-        assertTrue(list.get(1) == "World")
-        assertTrue(list[1] == "World")
-        assertTrue(list[-1] == "World")
-        assertTrue(list.getAt(1) == "World")
-        assertTrue(list.getAt(-2) == "Hello")
+        then:
+        list.get(1) == "World"
+        list[1] == "World"
+        list[-1] == "World"
+        list.getAt(1) == "World"
+        list.getAt(-2) == "Hello"
     }
 
-    @Test
-    void testAddItemsToList() {
+    def "testAddItemsToList"() {
+        given:
+        def list1 = []
+        def list2 = []
+        def list3 = [1, 2]
 
-        def list = []
+        when:
+        list1 << 1 // [1]
+        list1.add("Apple") // [1, "Apple"]
 
-        list << 1
-        list.add("Apple")
-        assertTrue(list == [1, "Apple"])
+        list2[2] = "Box"   // [null, "Box"]
+        list2[4] = true    // [null, "Box", null, true]
 
-        list[2] = "Box"
-        list[4] = true
-        assertTrue(list == [1, "Apple", "Box", null, true])
+        list1.add(1, 6.0) // [1, 6.0, "Apple"] 
+        list1 += list3                    // [1, 6.0, "Apple", 1, 2]
+        list1 += 12                       // [1, 6.0, "Apple", 1, 2, 12]
 
-        list.add(1, 6.0)
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true])
-
-        def list2 = [1, 2]
-        list += list2
-        list += 12
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])
+        then:
+        list1 == [1, 6.0, "Apple", 1, 2, 12]
+        list2 == [null, null, "Box", null, true]
     }
 
-    @Test
-    void testUpdateItemsInList() {
+    def "testUpdateItemsInList"() {
+        given:
+        def list = [1, "Apple", 80, "App"]
 
-        def list =[1, "Apple", 80, "App"]
+        when:
         list[1] = "Box"
-        list.set(2,90)
-        assertTrue(list == [1, "Box", 90, "App"])
+        list.set(2, 90)
+
+        then:
+        list == [1, "Box", 90, "App"]
     }
 
-    @Test
-    void testRemoveItemsFromList(){
-
+    def "testRemoveItemsFromList"() {
+        given:
         def list = [1, 2, 3, 4, 5, 5, 6, 6, 7]
 
-        list.remove(3)
-        assertTrue(list == [1, 2, 3, 5, 5, 6, 6, 7])
+        when:
+        list.remove(3) // [1, 2, 3, 5, 5, 6, 6, 7]
+        list.removeElement(5) // [1, 2, 3, 5, 6, 6, 7]
+        list = list - 6       // [1, 2, 3, 5, 7]
 
-        list.removeElement(5)
-        assertTrue(list == [1, 2, 3, 5, 6, 6, 7])
-
-        assertTrue(list - 6 == [1, 2, 3, 5, 7])
+        then:
+        list == [1, 2, 3, 5, 7]
     }
 
-    @Test
-    void testIteratingOnAList(){
-
+    def "testIteratingOnAList"() {
+        given:
         def list = [1, "App", 3, 4]
-        list.each{ println it * 2}
 
-        list.eachWithIndex{ it, i -> println "$i : $it" }
+        expect:
+        list.each { println it * 2 }
+        list.eachWithIndex { it, i -> println "$i : $it" }
     }
 
-    @Test
-    void testCollectingToAnotherList(){
-
+    def "testCollectingToAnotherList"() {
+        given:
         def list = ["Kay", "Henry", "Justin", "Tom"]
-        assertTrue(list.collect{"Hi " + it} == ["Hi Kay", "Hi Henry", "Hi Justin", "Hi Tom"])
+
+        when:
+        def collect = list.collect { "Hi " + it }
+
+        then:
+        collect == ["Hi Kay", "Hi Henry", "Hi Justin", "Hi Tom"]
     }
 
-    @Test
-    void testJoinItemsInAList(){
-        assertTrue(["One", "Two", "Three"].join(",") == "One,Two,Three")
+    def "testJoinItemsInAList"() {
+        expect:
+        ["One", "Two", "Three"].join(",") == "One,Two,Three"
     }
 
-    @Test
-    void testFilteringOnLists(){
+    def "testFilteringOnLists"() {
+        given:
         def filterList = [2, 1, 3, 4, 5, 6, 76]
-
-        assertTrue(filterList.find{it > 3} == 4)
-
-        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})
+        expect:
+        filterList.find { it > 3 } == 4
+        filterList.findAll { it > 3 } == [4, 5, 6, 76]
+        filterList.findAll { it instanceof Number } == [2, 1, 3, 4, 5, 6, 76]
+        filterList.grep(Number) == [2, 1, 3, 4, 5, 6, 76]
+        filterList.grep { it > 6 } == [76]
 
+        !(conditionList.every { it < 6 })
+        conditionList.any { it % 2 == 0 }
     }
 
-    @Test
-    void testGetUniqueItemsInAList(){
-        assertTrue([1, 3, 3, 4].toUnique() == [1, 3, 4])
-
+    def "testGetUniqueItemsInAList"() {
+        given:
         def uniqueList = [1, 3, 3, 4]
-        uniqueList.unique()
-        assertTrue(uniqueList == [1, 3, 4])
 
-        assertTrue(["A", "B", "Ba", "Bat", "Cat"].toUnique{ it.size()} == ["A", "Ba", "Bat"])
+        when:
+        uniqueList.unique(true)
+
+        then:
+        [1, 3, 3, 4].toUnique() == [1, 3, 4]
+        uniqueList == [1, 3, 4]
+        ["A", "B", "Ba", "Bat", "Cat"].toUnique { it.size() } == ["A", "Ba", "Bat"]
     }
 
-    @Test
-    void testSorting(){
-
-        assertTrue([1, 2, 1, 0].sort() == [0, 1, 1, 2])
-        Comparator mc = {a,b -> a == b? 0: a < b? 1 : -1}
-
+    def "testSorting"() {
+        given:
+        Comparator naturalOrder = { a, b -> a == b ? 0 : a < b ? -1 : 1 }
         def list = [1, 2, 1, 0]
-        list.sort(mc)
-        assertTrue(list == [2, 1, 1, 0])
-
         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)
+
+        when:
+        list.sort(naturalOrder.reversed())
+
+        then:
+        list == [2, 1, 1, 0]
+        strList.max() == "ppp"
+        [1, 2, 1, 0].sort() == [0, 1, 1, 2]
+        numberList.min(naturalOrder) == 0
     }
-}
+}

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/maps/MapTest.groovy

@@ -1,148 +1,160 @@
-package com.baeldung.maps;
+package com.baeldung.maps
 
-import static groovy.test.GroovyAssert.*
-import org.junit.Test
+import spock.lang.Specification
 
-class MapTest{
-
-    @Test
-    void createMap() {
+class MapTest extends Specification {
 
+    def "createMap"() {
+        when:
         def emptyMap = [:]
-        assertNotNull(emptyMap)
+        def map = [name: "Jerry", age: 42, city: "New York"]
 
-        assertTrue(emptyMap instanceof java.util.LinkedHashMap)
-
-        def map = [name:"Jerry", age: 42, city: "New York"]
-        assertTrue(map.size() == 3)
+        then:
+        emptyMap != null
+        emptyMap instanceof java.util.LinkedHashMap
+        map.size() == 3
     }
 
-    @Test
-    void addItemsToMap() {
-
-        def map = [name:"Jerry"]
-
-        map["age"] = 42
-
-        map.city = "New York"
-
+    def "addItemsToMap"() {
+        given:
+        def map = [name: "Jerry"]
         def hobbyLiteral = "hobby"
         def hobbyMap = [(hobbyLiteral): "Singing"]
+        def appendToMap = [:]
+
+        when:
+        map["age"] = 42
+        map.city = "New York"
+
         map.putAll(hobbyMap)
 
-        assertTrue(map == [name:"Jerry", age: 42, city: "New York", hobby:"Singing"])
-        assertTrue(hobbyMap.hobby == "Singing")
-        assertTrue(hobbyMap[hobbyLiteral] == "Singing")
-        
-        map.plus([1:20]) // returns new map
+        appendToMap.plus([1: 20])
+        appendToMap << [2: 30]
 
-        map << [2:30]
+        then:
+        map == [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
+        hobbyMap.hobby == "Singing"
+        hobbyMap[hobbyLiteral] == "Singing"
+
+        appendToMap == [2: 30] // plus(Map) returns new instance of Map
     }
 
-    @Test
-    void getItemsFromMap() {
-
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
-
-        assertTrue(map["name"] == "Jerry")
-
-        assertTrue(map.name == "Jerry")
-
+    def "getItemsFromMap"() {
+        when:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
         def propertyAge = "age"
-        assertTrue(map[propertyAge] == 42)
+
+        then:
+        map["name"] == "Jerry"
+        map.name == "Jerry"
+        map[propertyAge] == 42
+        map."$propertyAge" == 42
     }
 
-    @Test
-    void removeItemsFromMap() {
+    def "removeItemsFromMap"() {
+        given:
+        def map = [1: 20, a: 30, 2: 42, 4: 34, ba: 67, 6: 39, 7: 49]
+        def removeAllKeysOfTypeString = [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
+        def retainAllEntriesWhereValueIsEven = [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
 
-        def map = [1:20, a:30, 2:42, 4:34, ba:67, 6:39, 7:49]
+        when:
+        def minusMap = map - [2: 42, 4: 34]
+        removeAllKeysOfTypeString.removeAll { it.key instanceof String }
+        retainAllEntriesWhereValueIsEven.retainAll { it.value % 2 == 0 }
 
-        def minusMap = map.minus([2:42, 4:34]);
-        assertTrue(minusMap == [1:20, a:30, ba:67, 6:39, 7:49])
-
-        minusMap.removeAll{it -> it.key instanceof String}
-        assertTrue( minusMap == [ 1:20, 6:39, 7:49])
-
-        minusMap.retainAll{it -> it.value %2 == 0}
-        assertTrue( minusMap == [1:20])
+        then:
+        minusMap == [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
+        removeAllKeysOfTypeString == [1: 20, 6: 39, 7: 49]
+        retainAllEntriesWhereValueIsEven == [1: 20, a: 30]
     }
 
-    @Test
-    void iteratingOnMaps(){
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+    def "iteratingOnMaps"() {
+        when:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
-        map.each{ entry -> println "$entry.key: $entry.value" }
-
-        map.eachWithIndex{ entry, i -> println "$i $entry.key: $entry.value" }
-
-        map.eachWithIndex{ key, value, i -> println "$i $key: $value" }
+        then:
+        map.each { entry -> println "$entry.key: $entry.value" }
+        map.eachWithIndex { entry, i -> println "$i $entry.key: $entry.value" }
+        map.eachWithIndex { key, value, i -> println "$i $key: $value" }
     }
 
-    @Test
-    void filteringAndSearchingMaps(){
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+    def "filteringAndSearchingMaps"() {
+        given:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
-        assertTrue(map.find{ it.value == "New York"}.key == "city")
+        when:
+        def find = map.find { it.value == "New York" }
+        def finaAll = map.findAll { it.value == "New York" }
+        def grep = map.grep { it.value == "New York" }
+        def every = map.every { it -> it.value instanceof String }
+        def any = map.any { it -> it.value instanceof String }
 
-        assertTrue(map.findAll{ it.value == "New York"} == [city : "New York"])
+        then:
+        find.key == "city"
 
-        map.grep{it.value == "New York"}.each{ it -> assertTrue(it.key == "city" && it.value == "New York")}
+        finaAll instanceof Map
+        finaAll == [city: "New York"]
 
-        assertTrue(map.every{it -> it.value instanceof String} == false)
+        grep instanceof Collection
+        grep.each { it -> assert it.key == "city" && it.value == "New York" }
 
-        assertTrue(map.any{it -> it.value instanceof String} == true)
+        every instanceof Boolean
+        !every
+
+        any instanceof Boolean
+        any
     }
 
-    @Test
-    void collect(){
-
-        def map = [1: [name:"Jerry", age: 42, city: "New York"],
-            2: [name:"Long", age: 25, city: "New York"],
-            3: [name:"Dustin", age: 29, city: "New York"],
-            4: [name:"Dustin", age: 34, city: "New York"]]
-
-        def names = map.collect{entry -> entry.value.name} // returns only list
-        assertTrue(names == ["Jerry", "Long", "Dustin", "Dustin"])
-
-        def uniqueNames = map.collect([] as HashSet){entry -> entry.value.name}
-        assertTrue(uniqueNames == ["Jerry", "Long", "Dustin"] as Set)
-
-        def idNames = map.collectEntries{key, value -> [key, value.name]}
-        assertTrue(idNames == [1:"Jerry", 2: "Long", 3:"Dustin", 4: "Dustin"])
-
-        def below30Names = map.findAll{it.value.age < 30}.collect{key, value -> value.name}
-        assertTrue(below30Names == ["Long", "Dustin"])
+    def "collect"() {
+        given:
+        def map = [
+                1: [name: "Jerry", age: 42, city: "New York"],
+                2: [name: "Long", age: 25, city: "New York"],
+                3: [name: "Dustin", age: 29, city: "New York"],
+                4: [name: "Dustin", age: 34, city: "New York"]
+        ]
 
+        when:
+        def names = map.collect { entry -> entry.value.name } // returns only list
+        def uniqueNames = map.collect { entry -> entry.value.name }
+                             .unique()
+        def idNames = map.collectEntries { key, value -> [key, value.name] }
+        def below30Names = map.findAll { it.value.age < 30 }
+                              .collect { key, value -> value.name }
 
+        then:
+        names == ["Jerry", "Long", "Dustin", "Dustin"]
+        uniqueNames == ["Jerry", "Long", "Dustin"]
+        idNames == [1: "Jerry", 2: "Long", 3: "Dustin", 4: "Dustin"]
+        below30Names == ["Long", "Dustin"]
     }
 
-    @Test
-    void group(){
-        def map = [1:20, 2: 40, 3: 11, 4: 93]
-
-        def subMap = map.groupBy{it.value % 2}
-        println subMap
-        assertTrue(subMap == [0:[1:20, 2:40 ], 1:[3:11, 4:93]])
+    def "group"() {
+        given:
+        def map = [1: 20, 2: 40, 3: 11, 4: 93]
 
+        when:
+        def subMap = map.groupBy { it.value % 2 }
         def keySubMap = map.subMap([1, 2])
-        assertTrue(keySubMap == [1:20, 2:40])
 
+        then:
+        subMap == [0: [1: 20, 2: 40], 1: [3: 11, 4: 93]]
+        keySubMap == [1: 20, 2: 40]
     }
 
-    @Test
-    void sorting(){
-        def map = [ab:20, a: 40, cb: 11, ba: 93]
+    def "sorting"() {
+        given:
+        def map = [ab: 20, a: 40, cb: 11, ba: 93]
 
+        when:
         def naturallyOrderedMap = map.sort()
-        assertTrue([a:40, ab:20, ba:93, cb:11] == naturallyOrderedMap)
-
         def compSortedMap = map.sort({ k1, k2 -> k1 <=> k2 } as Comparator)
-        assertTrue([a:40, ab:20, ba:93, cb:11] == compSortedMap)
-
         def cloSortedMap = map.sort({ it1, it2 -> it1.value <=> it1.value })
-        assertTrue([cb:11, ab:20, a:40, ba:93] == cloSortedMap)
 
+        then:
+        naturallyOrderedMap == [a: 40, ab: 20, ba: 93, cb: 11]
+        compSortedMap == [a: 40, ab: 20, ba: 93, cb: 11]
+        cloSortedMap == [cb: 11, ab: 20, a: 40, ba: 93]
     }
-
 }

core-groovy-modules/core-groovy-strings/pom.xml

@@ -103,9 +103,10 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+</project>

core-groovy-modules/core-groovy-strings/src/test/groovy/com/baeldung/removeprefix/RemovePrefixTest.groovy

@@ -1,70 +1,74 @@
 package com.baeldung.removeprefix
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class RemovePrefixTest {
+class RemovePrefixTest extends Specification {
 
-
-    @Test
-    public void whenCasePrefixIsRemoved_thenReturnTrue() {
+    def "whenCasePrefixIsRemoved_thenReturnTrue"() {
+        given:
         def trimPrefix = {
             it.startsWith('Groovy-') ? it.minus('Groovy-') : it
         }
-        
+
+        when:
         def actual = trimPrefix("Groovy-Tutorials at Baeldung")
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemoved_thenReturnTrue() {
-
+    def "whenPrefixIsRemoved_thenReturnTrue"() {
+        given:
         String prefix = "groovy-"
         String trimPrefix = "Groovy-Tutorials at Baeldung"
-        def actual;
-        if(trimPrefix.startsWithIgnoreCase(prefix)) {
+
+        when:
+        def actual
+        if (trimPrefix.startsWithIgnoreCase(prefix)) {
             actual = trimPrefix.substring(prefix.length())
         }
-        
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemovedUsingRegex_thenReturnTrue() {
-
+    def "whenPrefixIsRemovedUsingRegex_thenReturnTrue"() {
+        given:
         def regex = ~"^([Gg])roovy-"
         String trimPrefix = "Groovy-Tutorials at Baeldung"
+
+        when:
         String actual = trimPrefix - regex
-        
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test 
-    public void whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue() {
-        def regex = ~"^groovy" 
-        String trimPrefix = "groovyTutorials at Baeldung's groovy page" 
+    def "whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue"() {
+        given:
+        def regex = ~"^groovy"
+        String trimPrefix = "groovyTutorials at Baeldung's groovy page"
+
+        when:
         String actual = trimPrefix.replaceFirst(regex, "")
-        
         def expected = "Tutorials at Baeldung's groovy page"
-        
-        Assert.assertEquals(expected, actual)
+
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue() {
-
+    def "whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue"() {
+        given:
         String trimPrefix = "groovyTutorials at Baeldung groovy"
+
+        when:
         String actual = trimPrefix.replaceAll(/^groovy/, "")
-        
         def expected = "Tutorials at Baeldung groovy"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
-
-}
+}

core-groovy-modules/core-groovy/pom.xml

@@ -3,6 +3,7 @@
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
+    
     <artifactId>core-groovy</artifactId>
     <version>1.0-SNAPSHOT</version>
     <name>core-groovy</name>
@@ -103,9 +104,10 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+</project>

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/file/ReadFile.groovy

@@ -10,13 +10,14 @@ class ReadFile {
     int readFileLineByLine(String filePath) {
         File file = new File(filePath)
         def line, noOfLines = 0;
+
         file.withReader { reader ->
-            while ((line = reader.readLine())!=null)
-            {
+            while ((line = reader.readLine()) != null) {
                 println "${line}"
                 noOfLines++
             }
         }
+
         return noOfLines
     }
 
@@ -26,9 +27,7 @@ class ReadFile {
      * @return
      */
     List<String> readFileInList(String filePath) {
-        File file = new File(filePath)
-        def lines = file.readLines()
-        return lines
+        return new File(filePath).readLines()
     }
 
     /**
@@ -37,9 +36,7 @@ class ReadFile {
      * @return
      */
     String readFileString(String filePath) {
-        File file = new File(filePath)
-        String fileContent = file.text
-        return fileContent
+        return new File(filePath).text
     }
 
     /**
@@ -48,9 +45,7 @@ class ReadFile {
      * @return
      */
     String readFileStringWithCharset(String filePath) {
-        File file = new File(filePath)
-        String utf8Content = file.getText("UTF-8")
-        return utf8Content
+        return new File(filePath).getText("UTF-8")
     }
 
     /**
@@ -59,49 +54,44 @@ class ReadFile {
      * @return
      */
     byte[] readBinaryFile(String filePath) {
-        File file = new File(filePath)
-        byte[] binaryContent = file.bytes
-        return binaryContent
+        return new File(filePath).bytes
     }
-    
+
     /**
      * More Examples of reading a file 
      * @return
      */
     def moreExamples() {
-        
+
         //with reader with utf-8
         new File("src/main/resources/utf8Content.html").withReader('UTF-8') { reader ->
             def line
-            while ((line = reader.readLine())!=null) { 
+            while ((line = reader.readLine()) != null) {
                 println "${line}"
             }
         }
-        
-        //collect api
-        def list = new File("src/main/resources/fileContent.txt").collect {it}
-                
-        //as operator
+
+        // collect api
+        def list = new File("src/main/resources/fileContent.txt").collect { it }
+
+        // as operator
         def array = new File("src/main/resources/fileContent.txt") as String[]
-              
-        //eachline  
-        new File("src/main/resources/fileContent.txt").eachLine { line ->
-            println line
-        }
-        
+
+        // eachline  
+        new File("src/main/resources/fileContent.txt").eachLine { println it }
+
         //newInputStream with eachLine
-        def is = new File("src/main/resources/fileContent.txt").newInputStream()
-        is.eachLine {
-            println it
+
+        // try-with-resources automatically closes BufferedInputStream resource
+        try (def inputStream = new File("src/main/resources/fileContent.txt").newInputStream()) {
+            inputStream.eachLine { println it }
         }
-        is.close()
-        
-        //withInputStream
+
+        // withInputStream
         new File("src/main/resources/fileContent.txt").withInputStream { stream ->
             stream.eachLine { line ->
                 println line
             }
         }
     }
-
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/strings/Concatenate.groovy

@@ -1,9 +1,10 @@
 package com.baeldung.strings;
 
 class Concatenate {
+
     String first = 'Hello'
     String last = 'Groovy'
-  
+
     String doSimpleConcat() {
         return 'My name is ' + first + ' ' + last
     }
@@ -23,21 +24,28 @@ class Concatenate {
     String doConcatUsingLeftShiftOperator() {
         return 'My name is ' << first << ' ' << last
     }
-    
+
     String doConcatUsingArrayJoinMethod() {
         return ['My name is', first, last].join(' ')
     }
 
     String doConcatUsingArrayInjectMethod() {
-        return  [first,' ', last]
-          .inject(new StringBuffer('My name is '), { initial, name -> initial.append(name); return initial }).toString()
+        return [first, ' ', last]
+                .inject(new StringBuffer('My name is '), { initial, name -> initial.append(name) })
+                .toString()
     }
- 
+
     String doConcatUsingStringBuilder() {
-        return new StringBuilder().append('My name is ').append(first).append(' ').append(last)
+        return new StringBuilder().append('My name is ')
+                                  .append(first)
+                                  .append(' ')
+                                  .append(last)
     }
 
     String doConcatUsingStringBuffer() {
-        return new StringBuffer().append('My name is ').append(first).append(' ').append(last)
+        return new StringBuffer().append('My name is ')
+                                 .append(first)
+                                 .append(' ')
+                                 .append(last)
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/AnimalTrait.groovy

@@ -1,8 +1,8 @@
 package com.baeldung.traits
 
 trait AnimalTrait {
-    
+
     String basicBehavior() {
         return "Animalistic!!"
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Dog.groovy

@@ -1,9 +1,8 @@
 package com.baeldung.traits
 
 class Dog implements WalkingTrait, SpeakingTrait {
-     
+    
     String speakAndWalk() {
         WalkingTrait.super.speakAndWalk()
     }
-    
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Employee.groovy

@@ -1,12 +1,14 @@
 package com.baeldung.traits
 
 class Employee implements UserTrait {
-    
+
+    @Override
     String name() {
         return 'Bob'
     }
     
+    @Override
     String lastName() {
         return "Marley"
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Human.groovy

@@ -1,6 +1,6 @@
 package com.baeldung.traits
 
 interface Human {
-    
+
     String lastName()
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/SpeakingTrait.groovy

@@ -1,13 +1,12 @@
 package com.baeldung.traits
 
 trait SpeakingTrait {
-    
+
     String basicAbility() {
         return "Speaking!!"
     }
-    
+
     String speakAndWalk() {
         return "Speak and walk!!"
     }
-    
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/UserTrait.groovy

@@ -1,36 +1,35 @@
 package com.baeldung.traits
 
 trait UserTrait implements Human {
-    
+
+    String email
+    String address
+
+    abstract String name()
+
     String sayHello() {
         return "Hello!"
     }
-    
-    abstract String name()
-    
+
     String showName() {
-       return "Hello, ${name()}!"
+        return "Hello, ${name()}!"
     }
 
     private String greetingMessage() {
         return 'Hello, from a private method!'
     }
-    
+
     String greet() {
         def msg = greetingMessage()
         println msg
         msg
     }
-    
+
     def self() {
-        return this 
+        return this
     }
-    
+
     String showLastName() {
         return "Hello, ${lastName()}!"
     }
-    
-    String email
-    String address
 }
-    

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/VehicleTrait.groovy

@@ -1,9 +1,9 @@
 package com.baeldung
 
 trait VehicleTrait extends WheelTrait {
-    
+
     String showWheels() {
-        return "Num of Wheels $noOfWheels" 
+        return "Num of Wheels $noOfWheels"
     }
-    
-}
+
+}