This is an automated email from the ASF dual-hosted git repository.

paulk pushed a commit to branch GROOVY_2_5_X
in repository https://gitbox.apache.org/repos/asf/groovy.git

commit 1630fc11f6f52270911e799811902e65185dc0eb
Author: Paul King <pa...@asert.com.au>
AuthorDate: Tue Jan 1 16:18:31 2019 +1000

    cleanup/remove @author tags as per Apache recommended practices cont'd
---
 gradle/pomconfigurer.gradle                        |   6 +
 .../test/builder/ObjectGraphBuilderTest.groovy     |   2 -
 src/test/gls/enums/EnumTest.groovy                 |   3 -
 src/test/gls/innerClass/InnerInterfaceTest.groovy  |   2 -
 src/test/gls/syntax/BinaryLiteralTest.groovy       |   4 -
 src/test/gls/syntax/Gep3OrderDslTest.groovy        |   3 -
 src/test/gls/syntax/UnderscoreInNumbersTest.groovy |   2 -
 src/test/groovy/AmbiguousInvocationTest.groovy     |   4 +-
 src/test/groovy/BinaryStreamsTest.groovy           |   2 -
 src/test/groovy/BreakContinueLabelTest.groovy      |   2 -
 src/test/groovy/CallInnerClassCtorTest.groovy      |   1 -
 src/test/groovy/ClassExpressionTest.groovy         |   2 -
 src/test/groovy/ClosureAsParamTest.groovy          |   3 -
 src/test/groovy/ClosureCloneTest.groovy            |   3 -
 src/test/groovy/ClosureComparatorTest.groovy       |   8 +-
 src/test/groovy/ClosureComposeTest.groovy          |   2 +-
 src/test/groovy/ClosureDefaultParameterTest.groovy |   3 -
 src/test/groovy/ClosureInStaticMethodTest.groovy   |  35 +++---
 src/test/groovy/ClosureMethodCallTest.groovy       |  41 +++---
 src/test/groovy/ClosureMethodTest.groovy           | 140 ++++++++++-----------
 src/test/groovy/ClosureMethodsOnFileTest.groovy    |   8 +-
 src/test/groovy/ClosureMissingMethodTest.groovy    |  93 +++++++-------
 src/test/groovy/ClosureReturnTest.groovy           |  12 +-
 src/test/groovy/ClosureTest.groovy                 |  54 ++++----
 .../groovy/ClosureUsingOuterVariablesTest.groovy   |  47 ++++---
 src/test/groovy/ClosureWithDefaultParamTest.groovy |  72 ++++++-----
 .../groovy/ClosureWithEmptyParametersTest.groovy   |   5 +-
 src/test/groovy/DummyMethodsGroovy.groovy          |   3 -
 src/test/groovy/ExceptionInClosureTest.groovy      |  11 +-
 29 files changed, 256 insertions(+), 317 deletions(-)

diff --git a/gradle/pomconfigurer.gradle b/gradle/pomconfigurer.gradle
index 828d408..6a5ce05 100644
--- a/gradle/pomconfigurer.gradle
+++ b/gradle/pomconfigurer.gradle
@@ -699,6 +699,12 @@ project.ext.pomConfigureClosureWithoutTweaks = {
                 name 'Martin Stockhammer'
             }
             contributor {
+                name 'Martin C. Martin'
+            }
+            contributor {
+                name 'Alexey Verkhovsky'
+            }
+            contributor {
                 name 'Alberto Mijares'
             }
             contributor {
diff --git a/src/spec/test/builder/ObjectGraphBuilderTest.groovy 
b/src/spec/test/builder/ObjectGraphBuilderTest.groovy
index f3e487f..3f3d987 100644
--- a/src/spec/test/builder/ObjectGraphBuilderTest.groovy
+++ b/src/spec/test/builder/ObjectGraphBuilderTest.groovy
@@ -24,8 +24,6 @@ import asciidoctor.Utils
 * Tests for ObjectGraphBuilder. The tests directly in this file are specific
 * to ObjectGraphBuilder. Functionality in common with other Builders
 * is tested in the parent class.
-*
-* @author Groovy Documentation Community
 */
 class ObjectGraphBuilderTest  extends GroovyTestCase {
 
diff --git a/src/test/gls/enums/EnumTest.groovy 
b/src/test/gls/enums/EnumTest.groovy
index e883ed1..684f55e 100644
--- a/src/test/gls/enums/EnumTest.groovy
+++ b/src/test/gls/enums/EnumTest.groovy
@@ -22,9 +22,6 @@ import gls.CompilableTestSupport
 
 /**
  * Tests various properties of enums.
- *
- * @author Paul King
- * @author Roshan Dawrani
  */
 class EnumTest extends CompilableTestSupport {
 
diff --git a/src/test/gls/innerClass/InnerInterfaceTest.groovy 
b/src/test/gls/innerClass/InnerInterfaceTest.groovy
index 8f66866..41d407a 100644
--- a/src/test/gls/innerClass/InnerInterfaceTest.groovy
+++ b/src/test/gls/innerClass/InnerInterfaceTest.groovy
@@ -20,8 +20,6 @@ package gls.innerClass
 
 /**
  * Tests on inner interface usage
- *
- * @author Roshan Dawrani
  */
 class InnerInterfaceTest extends GroovyTestCase {
 
diff --git a/src/test/gls/syntax/BinaryLiteralTest.groovy 
b/src/test/gls/syntax/BinaryLiteralTest.groovy
index c9b16a9..8cdea34 100644
--- a/src/test/gls/syntax/BinaryLiteralTest.groovy
+++ b/src/test/gls/syntax/BinaryLiteralTest.groovy
@@ -20,10 +20,6 @@ package gls.syntax
 
 import gls.CompilableTestSupport
 
-/**
- * 
- * @author Guillaume Laforge
- */
 class BinaryLiteralTest extends CompilableTestSupport {
 
     void testSomeBinaryLiteralNumbers() {
diff --git a/src/test/gls/syntax/Gep3OrderDslTest.groovy 
b/src/test/gls/syntax/Gep3OrderDslTest.groovy
index f906b5c..640beaa 100644
--- a/src/test/gls/syntax/Gep3OrderDslTest.groovy
+++ b/src/test/gls/syntax/Gep3OrderDslTest.groovy
@@ -20,9 +20,6 @@ package gls.syntax
 
 import org.codehaus.groovy.control.CompilerConfiguration
 
-/**
- * @author Guillaume Laforge
- */
 class Gep3OrderDslTest extends GroovyTestCase {
     @Override
     protected void setUp() {
diff --git a/src/test/gls/syntax/UnderscoreInNumbersTest.groovy 
b/src/test/gls/syntax/UnderscoreInNumbersTest.groovy
index 89bd2ac..084d23d 100644
--- a/src/test/gls/syntax/UnderscoreInNumbersTest.groovy
+++ b/src/test/gls/syntax/UnderscoreInNumbersTest.groovy
@@ -23,8 +23,6 @@ import gls.CompilableTestSupport
 /**
  * Most of the below examples were taken from the Project Coin proposal here:
  * http://mail.openjdk.java.net/pipermail/coin-dev/2009-April/001628.html
- * 
- * @author Guillaume Laforge
  */
 class UnderscoreInNumbersTest extends CompilableTestSupport {
 
diff --git a/src/test/groovy/AmbiguousInvocationTest.groovy 
b/src/test/groovy/AmbiguousInvocationTest.groovy
index 317812f..2172dc8 100644
--- a/src/test/groovy/AmbiguousInvocationTest.groovy
+++ b/src/test/groovy/AmbiguousInvocationTest.groovy
@@ -17,12 +17,10 @@
  *  under the License.
  */
 package groovy
+
 /**
  * to prove GROOVY-467 is no longer an issue    
- * 
- * @author <a href="mailto:jeremy.ray...@bigfoot.com";>Jeremy Rayner</a>
  */
-
 class AmbiguousInvocationTest extends GroovyTestCase {
     def dummy1, dummy2
 
diff --git a/src/test/groovy/BinaryStreamsTest.groovy 
b/src/test/groovy/BinaryStreamsTest.groovy
index 5c28d5c..de29ec1 100755
--- a/src/test/groovy/BinaryStreamsTest.groovy
+++ b/src/test/groovy/BinaryStreamsTest.groovy
@@ -18,8 +18,6 @@
  */
 /**
  * Test case for DefaultGroovyMethods involving Object streams and data 
streams.
- *
- * @author Martin C. Martin
  */
 class BinaryStreamsTest extends GroovyTestCase {
 
diff --git a/src/test/groovy/BreakContinueLabelTest.groovy 
b/src/test/groovy/BreakContinueLabelTest.groovy
index 3a37848..a993f20 100644
--- a/src/test/groovy/BreakContinueLabelTest.groovy
+++ b/src/test/groovy/BreakContinueLabelTest.groovy
@@ -22,8 +22,6 @@ import gls.CompilableTestSupport
 
 /**
  * todo: add BreakContinueLabelWithClosureTest (when break is used to return 
from a Closure)
-
- * @author Dierk Koenig
  */
 class BreakContinueLabelTest extends CompilableTestSupport {
 
diff --git a/src/test/groovy/CallInnerClassCtorTest.groovy 
b/src/test/groovy/CallInnerClassCtorTest.groovy
index 2c607c1..e422d5c 100644
--- a/src/test/groovy/CallInnerClassCtorTest.groovy
+++ b/src/test/groovy/CallInnerClassCtorTest.groovy
@@ -20,7 +20,6 @@ package groovy
 
 /**
  * Checks that it's possible to call inner classes constructor from groovy
- * @author Guillaume Laforge
  */
 class CallInnerClassCtorTest extends GroovyTestCase {
 
diff --git a/src/test/groovy/ClassExpressionTest.groovy 
b/src/test/groovy/ClassExpressionTest.groovy
index eccec72..69bcf05 100644
--- a/src/test/groovy/ClassExpressionTest.groovy
+++ b/src/test/groovy/ClassExpressionTest.groovy
@@ -20,8 +20,6 @@ package groovy
 
 /** 
  * Tests the use of classes as variable expressions
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClassExpressionTest extends GroovyTestCase {
 
diff --git a/src/test/groovy/ClosureAsParamTest.groovy 
b/src/test/groovy/ClosureAsParamTest.groovy
index 2196e21..03a0071 100644
--- a/src/test/groovy/ClosureAsParamTest.groovy
+++ b/src/test/groovy/ClosureAsParamTest.groovy
@@ -22,9 +22,6 @@ import java.util.concurrent.Callable
 
 /**
  * Tests calling methods with Closures as parameters.
- *
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
- * @author Paul King
  */
 class ClosureAsParamTest extends GroovyTestCase {
 
diff --git a/src/test/groovy/ClosureCloneTest.groovy 
b/src/test/groovy/ClosureCloneTest.groovy
index 5802dc9..adbe57b 100644
--- a/src/test/groovy/ClosureCloneTest.groovy
+++ b/src/test/groovy/ClosureCloneTest.groovy
@@ -18,9 +18,6 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:jstrac...@protique.com";>James Strachan</a>
- */
 class ClosureCloneTest extends GroovyTestCase {
 
     void testCloneOfClosure() {
diff --git a/src/test/groovy/ClosureComparatorTest.groovy 
b/src/test/groovy/ClosureComparatorTest.groovy
index 7ba887b..e0f7c3d 100644
--- a/src/test/groovy/ClosureComparatorTest.groovy
+++ b/src/test/groovy/ClosureComparatorTest.groovy
@@ -20,12 +20,10 @@ package groovy
 
 /**
  * Tests for ClosureComparator
- *
- * @author Alexey Verkhovsky
  */
 class ClosureComparatorTest extends GroovyTestCase {
 
-    public void testClosureComparatorForGroovyObjects() {
+    void testClosureComparatorForGroovyObjects() {
 
         def comparator = new ClosureComparator({ one, another ->
             one.greaterThan(another)
@@ -40,7 +38,7 @@ class ClosureComparatorTest extends GroovyTestCase {
 
     }
 
-    public void testClosureComparatorForNumericTypes() {
+    void testClosureComparatorForNumericTypes() {
 
         def comparator = new ClosureComparator({ one, another ->
             one - another
@@ -56,7 +54,7 @@ class ClosureComparatorTest extends GroovyTestCase {
 class ComparableFoo {
     long value
 
-    public ComparableFoo(long theValue) {
+    ComparableFoo(long theValue) {
         this.value = theValue
     }
 
diff --git a/src/test/groovy/ClosureComposeTest.groovy 
b/src/test/groovy/ClosureComposeTest.groovy
index 1c4e634..2f759a5 100644
--- a/src/test/groovy/ClosureComposeTest.groovy
+++ b/src/test/groovy/ClosureComposeTest.groovy
@@ -19,7 +19,7 @@
 package groovy
 
 /**
- * @author Paul King
+ * Tests for Closure composition
  */
 class ClosureComposeTest extends GroovyTestCase {
 
diff --git a/src/test/groovy/ClosureDefaultParameterTest.groovy 
b/src/test/groovy/ClosureDefaultParameterTest.groovy
index 71fc418..e9f8255 100644
--- a/src/test/groovy/ClosureDefaultParameterTest.groovy
+++ b/src/test/groovy/ClosureDefaultParameterTest.groovy
@@ -18,9 +18,6 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:jstrac...@protique.com";>James Strachan</a>
- */
 class ClosureDefaultParameterTest extends GroovyTestCase {
 
     void testClosureWithDefaultParams() {
diff --git a/src/test/groovy/ClosureInStaticMethodTest.groovy 
b/src/test/groovy/ClosureInStaticMethodTest.groovy
index 10cf86d..4b3766a 100644
--- a/src/test/groovy/ClosureInStaticMethodTest.groovy
+++ b/src/test/groovy/ClosureInStaticMethodTest.groovy
@@ -18,21 +18,18 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
- */
 class ClosureInStaticMethodTest extends GroovyTestCase {
 
     void testClosureInStaticMethod() {
         def closure = closureInStaticMethod()
-        assertClosure(closure)    
+        assertClosure(closure)
     }
 
     void testMethodClosureInStaticMethod() {
         def closure = methodClosureInStaticMethod()
-        assertClosure(closure)    
+        assertClosure(closure)
     }
-    
+
     static def closureInStaticMethod() {
         return { println(it) }
     }
@@ -40,25 +37,25 @@ class ClosureInStaticMethodTest extends GroovyTestCase {
     static def methodClosureInStaticMethod() {
         System.out.&println
     }
-    
+
     static def assertClosure(Closure block) {
         assert block != null
         block.call("hello!")
     }
-    
+
     void testClosureInStaticMethodCallingStaticMethod() {
-       assert doThing(1) == 10
-       assert this.doThing(1) == 10
-       assert ClosureInStaticMethodTest.doThing(1) == 10
+        assert doThing(1) == 10
+        assert this.doThing(1) == 10
+        assert ClosureInStaticMethodTest.doThing(1) == 10
     }
-    
-    
+
+
     static doThing(count) {
-      def ret = count
-      if (count > 2) return ret
-      count.times {
-        ret += doThing(count+it+1)
-      }
-      return ret
+        def ret = count
+        if (count > 2) return ret
+        count.times {
+            ret += doThing(count + it + 1)
+        }
+        return ret
     }
 }
diff --git a/src/test/groovy/ClosureMethodCallTest.groovy 
b/src/test/groovy/ClosureMethodCallTest.groovy
index d22bd0a..046aebf 100644
--- a/src/test/groovy/ClosureMethodCallTest.groovy
+++ b/src/test/groovy/ClosureMethodCallTest.groovy
@@ -18,15 +18,12 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
- */
 class ClosureMethodCallTest extends GroovyTestCase {
 
     void testCallingClosureWithMultipleArguments() {
         def foo
         def closure = { a, b -> foo = "hello ${a} and ${b}".toString() }
-        
+
         closure("james", "bob")
 
         assert foo == "hello james and bob"
@@ -35,45 +32,45 @@ class ClosureMethodCallTest extends GroovyTestCase {
 
         assert foo == "hello sam and james"
     }
-    
+
     void testClosureCallMethodWithObjectArray() {
         // GROOVY-2266
         def args = [1] as Object[]
-        def closure = {x -> x[0]}
+        def closure = { x -> x[0] }
         assert closure.call(args) == 1
     }
-    
+
     void testClosureWithStringArrayCastet() {
-        def doSomething={ list ->  list }
+        def doSomething = { list -> list }
 
-        String[] x=["hello", "world"]
-        String[] y=["hello", "world"]
+        String[] x = ["hello", "world"]
+        String[] y = ["hello", "world"]
 
         assert doSomething(x as String[]) == x
-        assert doSomething( y ) == y
+        assert doSomething(y) == y
     }
-    
+
     void testClosureAsLocalVar() {
-        def local = { Map params -> params.x * params.y  }
-        assert local(x : 2, y : 3) == 6
+        def local = { Map params -> params.x * params.y }
+        assert local(x: 2, y: 3) == 6
     }
-    
+
     void testClosureDirectly() {
-        assert { Map params -> params.x * params.y }(x : 2, y : 3) == 6
+        assert { Map params -> params.x * params.y }(x: 2, y: 3) == 6
     }
-    
+
     def attribute
-    
+
     void testClosureAsAttribute() {
-        attribute = { Map params ->  params.x * params.y  } 
-        assert attribute(x : 2, y : 3) == 6
+        attribute = { Map params -> params.x * params.y }
+        assert attribute(x: 2, y: 3) == 6
     }
-    
+
     void testSystemOutPrintlnAsAClosure() {
         def closure = System.out.&println
         closure("Hello world")
     }
-    
+
     //GROOVY-6819
     void test() {
         assertScript '''
diff --git a/src/test/groovy/ClosureMethodTest.groovy 
b/src/test/groovy/ClosureMethodTest.groovy
index 3b5de12..65a8438 100644
--- a/src/test/groovy/ClosureMethodTest.groovy
+++ b/src/test/groovy/ClosureMethodTest.groovy
@@ -22,22 +22,20 @@ import org.codehaus.groovy.runtime.DefaultGroovyMethods as 
DGM
 
 /**
  * Tests the various Closure methods in Groovy
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClosureMethodTest extends GroovyTestCase {
 
     void testListCollect() {
         def list = [1, 2, 3, 4]
-        def answer = list.collect{item -> return item * 2 }
+        def answer = list.collect { item -> return item * 2 }
         assert answer.size() == 4
         def expected = [2, 4, 6, 8]
         assert answer == expected
     }
 
     void testMapCollect() {
-        def map = [1:2, 2:4, 3:6, 4:8]
-        def answer = map.collect{e-> return e.key + e.value }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        def answer = map.collect { e -> return e.key + e.value }
         // lest sort the results since maps are in hash code order
         answer = answer.sort()
         assert answer.size() == 4
@@ -51,7 +49,7 @@ class ClosureMethodTest extends GroovyTestCase {
     void testObjectFindResult() {
         def oneToTenObjectIterator = {
             def i = 1
-            [ hasNext: { i <= 10 }, next: { i++ } ] as Iterator
+            [hasNext: { i <= 10 }, next: { i++ }] as Iterator
         }
 
         assert "Found 3" == oneToTenObjectIterator().findResult {
@@ -74,23 +72,23 @@ class ClosureMethodTest extends GroovyTestCase {
             if (false) return "won't get here, should return null"
         }
     }
-    
+
     void testListFind() {
         def list = ["a", "b", "c"]
-        def answer = list.find{item-> item == "b" }
+        def answer = list.find { item -> item == "b" }
         assert answer == "b"
-        answer = list.find{item-> item == "z" }
+        answer = list.find { item -> item == "z" }
         assert answer == null
     }
 
     void testListFindResult() {
         Collection<Integer> oneThroughFive = [1, 2, 3, 4, 5]
-        
-        assert "I found 4" == oneThroughFive.findResult { 
+
+        assert "I found 4" == oneThroughFive.findResult {
             if (it > 3) return "I found $it"
         }
 
-        assert null == oneThroughFive.findResult { 
+        assert null == oneThroughFive.findResult {
             if (it > 8) return "I found $it"
         }
 
@@ -100,38 +98,38 @@ class ClosureMethodTest extends GroovyTestCase {
 
         assert false == oneThroughFive.findResult {
             if (it > 3) return false  // a result of false is a valid result
-        }       
+        }
 
-        assert "I found 3" == oneThroughFive.findResult("default") { 
+        assert "I found 3" == oneThroughFive.findResult("default") {
             if (it > 2) return "I found $it"
         }
 
-        assert "default" == oneThroughFive.findResult("default") { 
+        assert "default" == oneThroughFive.findResult("default") {
             if (it > 8) return "I found $it"
         }
     }
 
     void testMapFind() {
-        def map = [1:2, 2:4, 3:6, 4:8]
-        def answer = map.find{entry -> entry.value == 6 }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        def answer = map.find { entry -> entry.value == 6 }
         assert answer != null
         assert answer.key == 3
         assert answer.value == 6
-        answer = map.find{entry -> entry.value == 0 }
+        answer = map.find { entry -> entry.value == 0 }
         assert answer == null
-        answer = map.find{ k, v -> v > 5 }
+        answer = map.find { k, v -> v > 5 }
         assert answer instanceof Map.Entry
         assert answer.key == 3
         assert answer.value == 6
 
-        answer = map.find{ k, v -> k == 2 }
+        answer = map.find { k, v -> k == 2 }
         assert answer instanceof Map.Entry
         assert answer.key == 2
         assert answer.value == 4
     }
 
     void testMapFindResult() {
-        def oneThroughFourMap = [a: 1, b: 2, c: 3, d: 4] 
+        def oneThroughFourMap = [a: 1, b: 2, c: 3, d: 4]
 
         assert "I found c:3" == oneThroughFourMap.findResult { entry ->
             if (entry.value > 2) return "I found ${entry.key}:${entry.value}"
@@ -141,7 +139,7 @@ class ClosureMethodTest extends GroovyTestCase {
             if (value > 2) return "I found ${key}:${value}"
         }
 
-        assert false == oneThroughFourMap.findResult { 
+        assert false == oneThroughFourMap.findResult {
             if (it.value > 2) return false // a result of false is a valid 
result
         }
 
@@ -156,14 +154,14 @@ class ClosureMethodTest extends GroovyTestCase {
 
     void testListFindAll() {
         def list = [20, 5, 40, 2]
-        def answer = list.findAll{item -> item < 10 }
+        def answer = list.findAll { item -> item < 10 }
         assert answer.size() == 2
         assert answer == [5, 2]
     }
 
     void testMapFindAll() {
-        def map = [1:2, 2:4, 3:6, 4:8]
-        def answer = map.findAll{ entry -> entry.value > 5 }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        def answer = map.findAll { entry -> entry.value > 5 }
         assert answer.size() == 2
         def keys = answer.collect { entry -> entry.key }
         def values = answer.collect { entry -> entry.value }
@@ -176,44 +174,44 @@ class ClosureMethodTest extends GroovyTestCase {
 
     void testMapEach() {
         def count = 0
-        def map = [1:2, 2:4, 3:6, 4:8]
-        map.each{e-> count = count + e.value }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        map.each { e -> count = count + e.value }
         assert count == 20
-        map.each{e-> count = count + e.value + e.key }
+        map.each { e -> count = count + e.value + e.key }
         assert count == 50
     }
 
     void testMapEachWith2Params() {
         def count = 0
-        def map = [1:2, 2:4, 3:6, 4:8]
-        map.each {key, value -> count = count + value }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        map.each { key, value -> count = count + value }
         assert count == 20
-        map.each {key, value -> count = count + value + key }
+        map.each { key, value -> count = count + value + key }
         assert count == 50
     }
 
     void testListEach() {
         def count = 0
         def list = [1, 2, 3, 4]
-        list.each({item-> count = count + item })
+        list.each({ item -> count = count + item })
         assert count == 10
-        list.each{item-> count = count + item }
+        list.each { item -> count = count + item }
         assert count == 20
     }
 
     void testListEvery() {
-        assert [1, 2, 3, 4].every {i-> return i < 5 }
-        assert [1, 2, 7, 4].every {i-> i < 5 } == false
-        assert [a:1, b:2, c:3].every {k,v -> k < 'd' && v < 4 }
-        assert ![a:1, b:2, c:3].every {k,v -> k < 'd' && v < 3 }
+        assert [1, 2, 3, 4].every { i -> return i < 5 }
+        assert [1, 2, 7, 4].every { i -> i < 5 } == false
+        assert [a: 1, b: 2, c: 3].every { k, v -> k < 'd' && v < 4 }
+        assert ![a: 1, b: 2, c: 3].every { k, v -> k < 'd' && v < 3 }
     }
 
     void testListAny() {
-        assert [1, 2, 3, 4].any {i-> return i < 5 }
-        assert [1, 2, 3, 4].any {i-> i > 3 }
-        assert [1, 2, 3, 4].any {i-> i > 5 } == false
-        assert [a:1, b:2, c:3].any { k,v -> k == 'c' }
-        def isThereAFourValue = [a:1, b:2, c:3].any{ k,v -> v == 4 }
+        assert [1, 2, 3, 4].any { i -> return i < 5 }
+        assert [1, 2, 3, 4].any { i -> i > 3 }
+        assert [1, 2, 3, 4].any { i -> i > 5 } == false
+        assert [a: 1, b: 2, c: 3].any { k, v -> k == 'c' }
+        def isThereAFourValue = [a: 1, b: 2, c: 3].any { k, v -> v == 4 }
         assert !isThereAFourValue
     }
 
@@ -238,24 +236,24 @@ class ClosureMethodTest extends GroovyTestCase {
 
     void testOneArgListInject() {
         // Check basic functionality
-        def value = [ 1, 2, 3 ].inject { c, item -> c + item }
+        def value = [1, 2, 3].inject { c, item -> c + item }
         assert value == 6
 
         // Check a use-case
-        value = [ [ 'tim', 'dave', 'chris' ],
-                  [ 'stuart', 'harry', 'tim' ],
-                  [ 'bert', 'tim', 'ernie' ] ]
-        assert value.inject { a, b -> a.intersect( b ) } == ['tim']
+        value = [['tim', 'dave', 'chris'],
+                 ['stuart', 'harry', 'tim'],
+                 ['bert', 'tim', 'ernie']]
+        assert value.inject { a, b -> a.intersect(b) } == ['tim']
 
         // Check edges
         try {
             [].inject { a, b -> a + b } == null
-            fail( "inject(Closure) on an emtpy list should throw a 
NoSuchElementException" )
+            fail("inject(Closure) on an emtpy list should throw a 
NoSuchElementException")
         }
-        catch ( NoSuchElementException e ) {
+        catch (NoSuchElementException e) {
         }
-        assert    [ 1 ].inject { a, b -> a + b } == 1
-        assert [ 1, 2 ].inject { a, b -> a + b } == 3
+        assert [1].inject { a, b -> a + b } == 1
+        assert [1, 2].inject { a, b -> a + b } == 3
     }
 
     void testOneArgObjectInject() {
@@ -264,28 +262,28 @@ class ClosureMethodTest extends GroovyTestCase {
 
         try {
             ([] as Object[]).inject { c, item -> c + item }
-            fail( "inject(Closure) on an emtpy Object[] should throw a 
NoSuchElementException" )
+            fail("inject(Closure) on an emtpy Object[] should throw a 
NoSuchElementException")
         }
-        catch ( NoSuchElementException e ) {
+        catch (NoSuchElementException e) {
         }
 
-        value = ([ 1 ] as Object[]).inject { c, item -> c + item }
+        value = ([1] as Object[]).inject { c, item -> c + item }
         assert value == 1
 
         def i = 1
-        def iter = [ hasNext:{ -> i < 5 }, next:{ -> i++ } ] as Iterator
+        def iter = [hasNext: { -> i < 5 }, next: { -> i++ }] as Iterator
         assert iter.inject { a, b -> a * b } == 24
 
         try {
-            iter = [ hasNext:{ -> false }, next:{ -> null } ] as Iterator
+            iter = [hasNext: { -> false }, next: { -> null }] as Iterator
             iter.inject { a, b -> a * b }
-            fail( "inject(Closure) on an exhaused iterator should throw a 
NoSuchElementException" )
+            fail("inject(Closure) on an exhaused iterator should throw a 
NoSuchElementException")
         }
-        catch ( NoSuchElementException e ) {
+        catch (NoSuchElementException e) {
         }
 
         i = 1
-        iter = [ hasNext:{ -> i <= 1 }, next:{ -> i++ } ] as Iterator
+        iter = [hasNext: { -> i <= 1 }, next: { -> i++ }] as Iterator
         assert iter.inject { a, b -> a * b } == 1
     }
 
@@ -295,34 +293,34 @@ class ClosureMethodTest extends GroovyTestCase {
         def checkEqual = { int a, b -> assert a == b; a }
         def sum = DGM.&sum
         def addThreeWays = [
-            items.sum(),
-            items.inject(0, sum),
-            items.inject(sum)
+                items.sum(),
+                items.inject(0, sum),
+                items.inject(sum)
         ]
         assert addThreeWays == [1234] * 3
         addThreeWays.inject(checkEqual)
 
         def addTwiceFourWays = [
-            items.inject(0){ int acc, next -> acc + twice(next) },
-            items.collect(twice).sum(),
-            items.collect(twice).inject(0, sum),
-            items.collect(twice).inject(sum)
+                items.inject(0) { int acc, next -> acc + twice(next) },
+                items.collect(twice).sum(),
+                items.collect(twice).inject(0, sum),
+                items.collect(twice).inject(sum)
         ]
         assert addTwiceFourWays == [2468] * 4
         addTwiceFourWays.inject(checkEqual)
     }
 
     void testObjectInject() {
-        def value = [1:1, 2:2, 3:3].inject('counting: ') { str, item -> str + 
item.value }
+        def value = [1: 1, 2: 2, 3: 3].inject('counting: ') { str, item -> str 
+ item.value }
         assert value == "counting: 123"
-        value = [1:1, 2:2, 3:3].inject(0) { c, item -> c + item.value }
+        value = [1: 1, 2: 2, 3: 3].inject(0) { c, item -> c + item.value }
         assert value == 6
     }
 
     void testIteratorInject() {
-        def value = [1:1, 2:2, 3:3].iterator().inject('counting: ') { str, 
item -> str + item.value }
+        def value = [1: 1, 2: 2, 3: 3].iterator().inject('counting: ') { str, 
item -> str + item.value }
         assert value == "counting: 123"
-        value = [1:1, 2:2, 3:3].iterator().inject(0) { c, item -> c + 
item.value }
+        value = [1: 1, 2: 2, 3: 3].iterator().inject(0) { c, item -> c + 
item.value }
         assert value == 6
     }
 
@@ -344,7 +342,7 @@ class ClosureMethodTest extends GroovyTestCase {
         }
         assert answer == ['hello', 'there', 'how', 'are', 'you']
     }
-    
+
     void testUpto() {
         def answer = []
         1.upto(5) { answer.add(it) }
diff --git a/src/test/groovy/ClosureMethodsOnFileTest.groovy 
b/src/test/groovy/ClosureMethodsOnFileTest.groovy
index ca54a11..0d6f90f 100644
--- a/src/test/groovy/ClosureMethodsOnFileTest.groovy
+++ b/src/test/groovy/ClosureMethodsOnFileTest.groovy
@@ -18,20 +18,18 @@
  */
 package groovy
 
-/** 
+/**
  * Tests various Closure methods in Groovy on file
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClosureMethodsOnFileTest extends GroovyTestCase {
     private File file = new File("src/test/groovy/Bar.groovy")
     private File dir = new File("src/test/groovy")
 
     protected void setUp() {
-        if(!file.exists()) {
+        if (!file.exists()) {
             file = new File("Bar.groovy")
         }
-        if(!dir.exists()) {
+        if (!dir.exists()) {
             dir = new File(".")
         }
     }
diff --git a/src/test/groovy/ClosureMissingMethodTest.groovy 
b/src/test/groovy/ClosureMissingMethodTest.groovy
index f058b94..bb97eed 100644
--- a/src/test/groovy/ClosureMissingMethodTest.groovy
+++ b/src/test/groovy/ClosureMissingMethodTest.groovy
@@ -18,14 +18,11 @@
  */
 package groovy
 
-/**
- * @author Danno Ferrin
- */
 class ClosureMissingMethodTest extends GroovyTestCase {
 
-  void testInScript() {
-      GroovyShell shell = new GroovyShell()
-      shell.evaluate("""
+    void testInScript() {
+        GroovyShell shell = new GroovyShell()
+        shell.evaluate("""
           int count = 0
 
           foo = {
@@ -47,31 +44,31 @@ class ClosureMissingMethodTest extends GroovyTestCase {
               assert count == 1
           }
       """);
-  }
+    }
 
-  void testInMethod() {
-      int count = 0
+    void testInMethod() {
+        int count = 0
 
-      def foo = {
-          count++
-          bar()
-      }
-      def baz = {
-          foo()
-      }
+        def foo = {
+            count++
+            bar()
+        }
+        def baz = {
+            foo()
+        }
 
-      try {
-          baz()
-          fail()
-      } catch (MissingMethodException mme) {
-          assert mme.method == 'bar'
-          assert count == 1
-      }
-  }
+        try {
+            baz()
+            fail()
+        } catch (MissingMethodException mme) {
+            assert mme.method == 'bar'
+            assert count == 1
+        }
+    }
 
-  void testWithMetaClassInScript() {
-      GroovyShell shell = new GroovyShell()
-      shell.evaluate("""
+    void testWithMetaClassInScript() {
+        GroovyShell shell = new GroovyShell()
+        shell.evaluate("""
           int count = 0
 
           foo = {
@@ -96,28 +93,28 @@ class ClosureMissingMethodTest extends GroovyTestCase {
               assert count == 1
           }
       """);
-  }
+    }
 
-  void testWithMetaClassInMethod() {
-      int count = 0
+    void testWithMetaClassInMethod() {
+        int count = 0
 
-      def foo = {
-          count++
-          bar()
-      }
-      def baz = {
-          foo()
-      }
-      MetaClass mc = new ExpandoMetaClass(baz.getClass())
-      mc.initialize()
-      baz.metaClass = mc
+        def foo = {
+            count++
+            bar()
+        }
+        def baz = {
+            foo()
+        }
+        MetaClass mc = new ExpandoMetaClass(baz.getClass())
+        mc.initialize()
+        baz.metaClass = mc
 
-      try {
-          baz()
-          fail()
-      } catch (MissingMethodException mme) {
-          assert mme.method == 'bar'
-          assert count == 1
-      }
-  }
+        try {
+            baz()
+            fail()
+        } catch (MissingMethodException mme) {
+            assert mme.method == 'bar'
+            assert count == 1
+        }
+    }
 }
diff --git a/src/test/groovy/ClosureReturnTest.groovy 
b/src/test/groovy/ClosureReturnTest.groovy
index b07ee17..3842e56 100644
--- a/src/test/groovy/ClosureReturnTest.groovy
+++ b/src/test/groovy/ClosureReturnTest.groovy
@@ -18,15 +18,13 @@
  */
 package groovy
 
-/** 
+/**
  * Tests Closures in Groovy
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClosureReturnTest extends GroovyTestCase {
 
     void testReturnValues() {
-        def block = {x-> return x > 5}
+        def block = { x -> return x > 5 }
 
         def value = block.call(10)
         assert value
@@ -36,15 +34,15 @@ class ClosureReturnTest extends GroovyTestCase {
     }
 
     void testReturnValueUsingFunction() {
-        def block = {x-> return someFunction(x) }
-        
+        def block = { x -> return someFunction(x) }
+
         def value = block.call(10)
         assert value
 
         value = block.call(3)
         assert value == false
     }
-    
+
     def someFunction(x) {
         return x > 5
     }
diff --git a/src/test/groovy/ClosureTest.groovy 
b/src/test/groovy/ClosureTest.groovy
index c36d10a..b4d9607 100644
--- a/src/test/groovy/ClosureTest.groovy
+++ b/src/test/groovy/ClosureTest.groovy
@@ -22,10 +22,8 @@ import 
org.codehaus.groovy.control.MultipleCompilationErrorsException
 
 import static groovy.lang.Closure.IDENTITY
 
-/** 
+/**
  * Tests Closures in Groovy
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClosureTest extends GroovyTestCase {
 
@@ -34,18 +32,18 @@ class ClosureTest extends GroovyTestCase {
     void testSimpleBlockCall() {
         count = 0
 
-        def block = {owner-> owner.incrementCallCount() }
+        def block = { owner -> owner.incrementCallCount() }
 
         assertClosure(block)
         assert count == 1
 
-        assertClosure({owner-> owner.incrementCallCount() })
+        assertClosure({ owner -> owner.incrementCallCount() })
         assert count == 2
     }
 
     void testVariableLengthParameterList() {
 
-        def c1 = {Object[] args -> args.each{count += it}}
+        def c1 = { Object[] args -> args.each { count += it } }
 
         count = 0
         c1(1, 2, 3)
@@ -59,7 +57,7 @@ class ClosureTest extends GroovyTestCase {
         c1([1, 2, 3] as Object[])
         assert count == 6
 
-        def c2 = {a, Object[] args -> count += a; args.each{count += it}}
+        def c2 = { a, Object[] args -> count += a; args.each { count += it } }
 
         count = 0
         c2(1, 2, 3)
@@ -77,13 +75,13 @@ class ClosureTest extends GroovyTestCase {
     void testBlockAsParameter() {
         count = 0
 
-        callBlock(5, {owner-> owner.incrementCallCount() })
+        callBlock(5, { owner -> owner.incrementCallCount() })
         assert count == 6
 
-        callBlock2(5, {owner-> owner.incrementCallCount() })
+        callBlock2(5, { owner -> owner.incrementCallCount() })
         assert count == 12
     }
-  
+
     void testMethodClosure() {
         def block = this.&incrementCallCount
 
@@ -97,7 +95,7 @@ class ClosureTest extends GroovyTestCase {
 
         assert block.call(3, 7) == 3
     }
-  
+
     def incrementCallCount() {
         //System.out.println("invoked increment method!")
         count = count + 1
@@ -109,13 +107,13 @@ class ClosureTest extends GroovyTestCase {
     }
 
     protected void callBlock(Integer num, Closure block) {
-        for ( i in 0..num ) {
+        for (i in 0..num) {
             block.call(this)
         }
     }
 
     protected void callBlock2(num, block) {
-        for ( i in 0..num ) {
+        for (i in 0..num) {
             block.call(this)
         }
     }
@@ -138,7 +136,7 @@ class ClosureTest extends GroovyTestCase {
     void testWithIndex() {
         def str = ''
         def sum = 0
-        ['a','b','c','d'].eachWithIndex { item, index -> str += item; sum += 
index }
+        ['a', 'b', 'c', 'd'].eachWithIndex { item, index -> str += item; sum 
+= index }
         assert str == 'abcd' && sum == 6
     }
 
@@ -146,7 +144,7 @@ class ClosureTest extends GroovyTestCase {
         def keyStr = ''
         def valStr = ''
         def sum = 0
-        ['a':'z','b':'y','c':'x','d':'w'].eachWithIndex { entry, index ->
+        ['a': 'z', 'b': 'y', 'c': 'x', 'd': 'w'].eachWithIndex { entry, index 
->
             keyStr += entry.key
             valStr += entry.value
             sum += index
@@ -158,7 +156,7 @@ class ClosureTest extends GroovyTestCase {
         def keyStr = ''
         def valStr = ''
         def sum = 0
-        ['a':'z','b':'y','c':'x','d':'w'].eachWithIndex { k, v, index ->
+        ['a': 'z', 'b': 'y', 'c': 'x', 'd': 'w'].eachWithIndex { k, v, index ->
             keyStr += k
             valStr += v
             sum += index
@@ -167,9 +165,9 @@ class ClosureTest extends GroovyTestCase {
     }
 
     /**
-    * Test access to Closure's properties
-    * cf GROOVY-2089
-    */
+     * Test access to Closure's properties
+     * cf GROOVY-2089
+     */
     void testGetProperties() {
         def c = { println it }
 
@@ -211,14 +209,14 @@ class ClosureTest extends GroovyTestCase {
 
         // like in testGetProperties(), don't know how to test metaClass 
property
     }
-    
+
     /**
      * GROOVY-2150 ensure list call is available on closure
      */
     void testCallClosureWithlist() {
-      def list = [1,2]
-      def cl = {a,b->a+b }
-      assert cl(list)==3
+        def list = [1, 2]
+        def cl = { a, b -> a + b }
+        assert cl(list) == 3
     }
 
     /**
@@ -245,7 +243,7 @@ class ClosureTest extends GroovyTestCase {
         def items = [0, 1, 2, '', 'foo', [], ['bar'], true, false]
         assert items.grep(IDENTITY) == [1, 2, 'foo', ['bar'], true]
         assert items.findAll(IDENTITY) == [1, 2, 'foo', ['bar'], true]
-        assert items.grep(IDENTITY).groupBy(IDENTITY) == [1:[1], 2:[2], 
'foo':['foo'], ['bar']:[['bar']], (true):[true]]
+        assert items.grep(IDENTITY).groupBy(IDENTITY) == [1: [1], 2: [2], 
'foo': ['foo'], ['bar']: [['bar']], (true): [true]]
         assert items.collect(IDENTITY) == items
 
         def twice = { it + it }
@@ -259,21 +257,21 @@ class ClosureTest extends GroovyTestCase {
         def foo = IDENTITY.rcurry('foo')
         assert foo() == 'foo'
 
-        def map = [a:1, b:2]
+        def map = [a: 1, b: 2]
         assert map.collectEntries(IDENTITY) == map
     }
-    
+
     void testEachWithArray() {
         def l = []
         l << ([1, 2] as Object[])
         l.each {
-                assert it == [1,2] as Object[]
+            assert it == [1, 2] as Object[]
         }
     }
 
     void testClosureDehydrateAndRehydrate() {
         def closure = { 'Hello' }
-        assert closure.delegate !=null
+        assert closure.delegate != null
         assert closure.owner != null
         assert closure.thisObject != null
         assert closure() == 'Hello'
diff --git a/src/test/groovy/ClosureUsingOuterVariablesTest.groovy 
b/src/test/groovy/ClosureUsingOuterVariablesTest.groovy
index b1c4108..3aa87a5 100644
--- a/src/test/groovy/ClosureUsingOuterVariablesTest.groovy
+++ b/src/test/groovy/ClosureUsingOuterVariablesTest.groovy
@@ -18,16 +18,13 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
- */
 class ClosureUsingOuterVariablesTest extends GroovyTestCase {
-    
+
     void testUseOfOuterVariable() {
-        
+
         def x = 123
         def y = "hello"
-        
+
         def closure = { i ->
             assert x == 123
             assert y == 'hello'
@@ -36,27 +33,27 @@ class ClosureUsingOuterVariablesTest extends GroovyTestCase 
{
         closure.call(321)
     }
 
-     /*
-     TODO: is this a valid test case?
-     void testInnerVariablesVisibleInOuterScope() {
-                
-        closure = { z = 456 } 
-        closure.call(321)
-        
-        assert z == 456
-    }
-    */
-    
+    /*
+    TODO: is this a valid test case?
+    void testInnerVariablesVisibleInOuterScope() {
+
+       closure = { z = 456 }
+       closure.call(321)
+
+       assert z == 456
+   }
+   */
+
     void testModifyingOuterVariable() {
-        
+
         def m = 123
-        
-        def closure = { m = 456 } 
+
+        def closure = { m = 456 }
         closure.call(321)
-        
+
         assert m == 456
     }
-    
+
     void testCounting() {
         def sum = 0
 
@@ -64,15 +61,15 @@ class ClosureUsingOuterVariablesTest extends GroovyTestCase 
{
 
         assert sum == 10
     }
-    
+
     void testExampleUseOfClosureScopes() {
         def a = 123
         def b
         def c = { b = a + it }
         c(5)
-        
+
         assert b == a + 5
-    }    
+    }
 
     void testExampleUseOfClosureScopesUsingEach() {
         def a = 123
diff --git a/src/test/groovy/ClosureWithDefaultParamTest.groovy 
b/src/test/groovy/ClosureWithDefaultParamTest.groovy
index dd293d6..567e5c3 100644
--- a/src/test/groovy/ClosureWithDefaultParamTest.groovy
+++ b/src/test/groovy/ClosureWithDefaultParamTest.groovy
@@ -18,14 +18,12 @@
  */
 package groovy
 
-/** 
+/**
  * Demonstrates the use of the default named parameter in a closure
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ClosureWithDefaultParamTest extends GroovyTestCase {
 
-    void methodWithDefaultParam(example='default'){
+    void methodWithDefaultParam(example = 'default') {
         assert 'default' == example
     }
 
@@ -34,18 +32,18 @@ class ClosureWithDefaultParamTest extends GroovyTestCase {
         def answer = list.collect { it * 2 }
 
         assert answer.size() == 4
-        
+
         def expected = [2, 4, 6, 8]
         assert answer == expected
     }
 
     void testMapCollect() {
-        def map = [1:2, 2:4, 3:6, 4:8]
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
         def answer = map.collect { it.key + it.value }
-        
+
         // lest sort the results since maps are in hash code order
         answer = answer.sort()
-        
+
         assert answer.size() == 4
         assert answer == [3, 6, 9, 12]
         assert answer.get(0) == 3
@@ -56,45 +54,45 @@ class ClosureWithDefaultParamTest extends GroovyTestCase {
 
     void testListFind() {
         def list = ["a", "b", "c"]
-        def answer = list.find {it == "b" }
+        def answer = list.find { it == "b" }
         assert answer == "b"
-        
-        answer = list.find {it == "z" }
+
+        answer = list.find { it == "z" }
         assert answer == null
     }
-    
+
     void testMapFind() {
-        def map = [1:2, 2:4, 3:6, 4:8]
-        def answer = map.find {it.value == 6 }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        def answer = map.find { it.value == 6 }
         assert answer != null
         assert answer.key == 3
         assert answer.value == 6
-        
-        answer = map.find {it.value == 0 }
+
+        answer = map.find { it.value == 0 }
         assert answer == null
     }
 
     void testListFindAll() {
         def list = [20, 5, 40, 2]
-        def answer = list.findAll {it < 10 }
+        def answer = list.findAll { it < 10 }
 
         assert answer.size() == 2
         assert answer == [5, 2]
     }
-    
+
     void testMapFindAll() {
-        def map = [1:2, 2:4, 3:6, 4:8]
-        def answer = map.findAll {it.value > 5 }
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
+        def answer = map.findAll { it.value > 5 }
 
         assert answer.size() == 2
-        
-        def keys = answer.collect {it.key }
-        def values = answer.collect {it.value }
+
+        def keys = answer.collect { it.key }
+        def values = answer.collect { it.value }
 
         // maps are in hash order so lets sort the results
-        keys.sort() 
-        values.sort() 
-        
+        keys.sort()
+        values.sort()
+
         assert keys == [3, 4]
         assert values == [6, 8]
     }
@@ -104,23 +102,23 @@ class ClosureWithDefaultParamTest extends GroovyTestCase {
 
         def list = [1, 2, 3, 4]
         list.each { count = count + it }
-        
+
         assert count == 10
 
         list.each { count = count + it }
-        
+
         assert count == 20
     }
 
     void testMapEach() {
         def count = 0
 
-        def map = [1:2, 2:4, 3:6, 4:8]
+        def map = [1: 2, 2: 4, 3: 6, 4: 8]
         map.each { count = count + it.value }
 
         assert count == 20
     }
-    
+
     void testListEvery() {
         assert [1, 2, 3, 4].every { it < 5 }
         assert [1, 2, 7, 4].every { it < 5 } == false
@@ -131,32 +129,32 @@ class ClosureWithDefaultParamTest extends GroovyTestCase {
         assert [1, 2, 3, 4].any { it > 3 }
         assert [1, 2, 3, 4].any { it > 5 } == false
     }
-    
+
     void testJoin() {
         def value = [1, 2, 3].join('-')
         assert value == "1-2-3"
     }
-    
+
     void testListReverse() {
         def value = [1, 2, 3, 4].reverse()
         assert value == [4, 3, 2, 1]
     }
-    
+
     void testEachLine() {
         def file = new File("src/test/groovy/Bar.groovy")
-        
+
         file.eachLine { assert it != null }
     }
-    
+
     void testReadLines() {
         def file = new File("src/test/groovy/Bar.groovy")
 
         def lines = file.readLines()
-        
+
         assert lines != null
         assert lines.size() > 0
     }
-    
+
     void testEachFile() {
         def file = new File("src/test/groovy")
 
diff --git a/src/test/groovy/ClosureWithEmptyParametersTest.groovy 
b/src/test/groovy/ClosureWithEmptyParametersTest.groovy
index c65a677..ab14a84 100644
--- a/src/test/groovy/ClosureWithEmptyParametersTest.groovy
+++ b/src/test/groovy/ClosureWithEmptyParametersTest.groovy
@@ -18,14 +18,11 @@
  */
 package groovy
 
-/** 
- * @author <a href="mailto:jstrac...@protique.com";>James Strachan</a>
- */
 class ClosureWithEmptyParametersTest extends GroovyTestCase {
 
     void testNoParams() {
 
-        def block = {-> }
+        def block = { -> }
 
         block.call()
     }
diff --git a/src/test/groovy/DummyMethodsGroovy.groovy 
b/src/test/groovy/DummyMethodsGroovy.groovy
index 49698a2..040e281 100644
--- a/src/test/groovy/DummyMethodsGroovy.groovy
+++ b/src/test/groovy/DummyMethodsGroovy.groovy
@@ -21,9 +21,6 @@ package groovy
 /**
  * Methods with specific parameters (e.g.&#160;primitives)
  * for use with groovy tests.
- *
- * @author <a href="mailto:jeremy.ray...@bigfoot.com";>Jeremy Rayner</a>
- *
  */
 class DummyMethodsGroovy {
     static void main(String[] args) {
diff --git a/src/test/groovy/ExceptionInClosureTest.groovy 
b/src/test/groovy/ExceptionInClosureTest.groovy
index 56caef0..42c2690 100644
--- a/src/test/groovy/ExceptionInClosureTest.groovy
+++ b/src/test/groovy/ExceptionInClosureTest.groovy
@@ -18,24 +18,21 @@
  */
 package groovy
 
-/** 
+/**
  * Tests exception handling inside of a closure
- * 
- * @author <a href="mailto:ja...@coredevelopers.net";>James Strachan</a>
  */
 class ExceptionInClosureTest extends GroovyTestCase {
 
     void testCallingOfFailedClosure() {
         def closure = { it -> it.foo() }
-        
+
         try {
             closure.call("cheese")
-            
             fail("Should have thrown an exception by now")
         }
         catch (MissingMethodException e) {
-               assert e.method == "foo"
-            assert e.type == String               
+            assert e.method == "foo"
+            assert e.type == String
         }
     }
 }

Reply via email to