View Javadoc

    1   /*
    2    $Id: GroovyTestCase.java,v 1.16 2005/01/05 21:34:32 glaforge Exp $
    3
    4    Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
    5
    6    Redistribution and use of this software and associated documentation
    7    ("Software"), with or without modification, are permitted provided
    8    that the following conditions are met:
    9
    10   1. Redistributions of source code must retain copyright
    11      statements and notices.  Redistributions must also contain a
    12      copy of this document.
    13
    14   2. Redistributions in binary form must reproduce the
    15      above copyright notice, this list of conditions and the
    16      following disclaimer in the documentation and/or other
    17      materials provided with the distribution.
    18
    19   3. The name "groovy" must not be used to endorse or promote
    20      products derived from this Software without prior written
    21      permission of The Codehaus.  For written permission,
    22      please contact info@codehaus.org.
    23
    24   4. Products derived from this Software may not be called "groovy"
    25      nor may "groovy" appear in their names without prior written
    26      permission of The Codehaus. "groovy" is a registered
    27      trademark of The Codehaus.
    28
    29   5. Due credit should be given to The Codehaus -
    30      http://groovy.codehaus.org/
    31
    32   THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
    33   ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
    34   NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
    35   FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
    36   THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
    37   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    38   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    39   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
    40   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
    41   STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    42   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
    43   OF THE POSSIBILITY OF SUCH DAMAGE.
    44
    45   */
    46  package groovy.util;
    47
    48  import groovy.lang.Closure;
    49  import groovy.lang.GroovyCodeSource;
    50  import groovy.lang.GroovyShell;
    51
    52  import java.io.File;
    53  import java.io.PrintWriter;
    54  import java.util.logging.Logger;
    55
    56  import junit.framework.TestCase;
    57
    58  import org.codehaus.groovy.runtime.DefaultGroovyMethods;
    59  import org.codehaus.groovy.runtime.InvokerHelper;
    60
    61  /***
    62   * A default JUnit TestCase in Groovy. This provides a number of helper methods
    63   * plus avoids the JUnit restriction of requiring all test* methods to be void
    64   * return type.
    65   *
    66   * @author <a href="mailto:bob@werken.com">bob mcwhirter</a>
    67   * @author <a href="mailto:james@coredevelopers.net">James Strachan</a>
    68   * @version $Revision: 1.16 $
    69   */
    70  public class GroovyTestCase extends TestCase {
    71
    72      protected Logger log = Logger.getLogger(getClass().getName());
    73      private static int counter;
    74      private boolean useAgileDoxNaming = false;
    75
    76      public GroovyTestCase() {
    77      }
    78
    79      /***
    80       * Overload the getName() method to make the test cases look more like AgileDox
    81       * (thanks to Joe Walnes for this tip!)
    82       */
    83      public String getName() {
    84          if (useAgileDoxNaming) {
    85              return super.getName().substring(4).replaceAll("([A-Z])", " $1").toLowerCase();
    86          }
    87          else {
    88              return super.getName();
    89          }
    90      }
    91
    92      public String getMethodName() {
    93          return super.getName();
    94      }
    95
    96      /***
    97       * Asserts that the arrays are equivalent and contain the same values
    98       *
    99       * @param expected
    100      * @param value
    101      */
    102     protected void assertArrayEquals(Object[] expected, Object[] value) {
    103         String message =
    104             "expected array: " + InvokerHelper.toString(expected) + " value array: " + InvokerHelper.toString(value);
    105         assertNotNull(message + ": expected should not be null", value);
    106         assertNotNull(message + ": value should not be null", value);
    107         assertEquals(message, expected.length, value.length);
    108         for (int i = 0, size = expected.length; i < size; i++) {
    109             assertEquals("value[" + i + "] when " + message, expected[i], value[i]);
    110         }
    111     }
    112
    113     /***
    114      * Asserts that the array of characters has a given length
    115      *
    116      * @param length expected length
    117      * @param array the array
    118      */
    119     protected void assertLength(int length, char[] array) {
    120         assertEquals(length, array.length);
    121     }
    122
    123     /***
    124      * Asserts that the array of ints has a given length
    125      *
    126      * @param length expected length
    127      * @param array the array
    128      */
    129     protected void assertLength(int length, int[] array) {
    130         assertEquals(length, array.length);
    131     }
    132
    133     /***
    134      * Asserts that the array of objects has a given length
    135      *
    136      * @param length expected length
    137      * @param array the array
    138      */
    139     protected void assertLength(int length, Object[] array) {
    140         assertEquals(length, array.length);
    141     }
    142
    143     /***
    144      * Asserts that the array of characters contains a given char
    145      *
    146      * @param expected expected character to be found
    147      * @param array the array
    148      */
    149     protected void assertContains(char expected, char[] array) {
    150         for (int i = 0; i < array.length; ++i) {
    151             if (array[i] == expected) {
    152                 return;
    153             }
    154         }
    155
    156         StringBuffer message = new StringBuffer();
    157
    158         message.append(expected + " not in {");
    159
    160         for (int i = 0; i < array.length; ++i) {
    161             message.append("'" + array[i] + "'");
    162
    163             if (i < (array.length - 1)) {
    164                 message.append(", ");
    165             }
    166         }
    167
    168         message.append(" }");
    169
    170         fail(message.toString());
    171     }
    172
    173     /***
    174      * Asserts that the array of ints contains a given int
    175      *
    176      * @param expected expected int
    177      * @param array the array
    178      */
    179     protected void assertContains(int expected, int[] array) {
    180         for (int i = 0; i < array.length; ++i) {
    181             if (array[i] == expected) {
    182                 return;
    183             }
    184         }
    185
    186         StringBuffer message = new StringBuffer();
    187
    188         message.append(expected + " not in {");
    189
    190         for (int i = 0; i < array.length; ++i) {
    191             message.append("'" + array[i] + "'");
    192
    193             if (i < (array.length - 1)) {
    194                 message.append(", ");
    195             }
    196         }
    197
    198         message.append(" }");
    199
    200         fail(message.toString());
    201     }
    202
    203     /***
    204      * Asserts that the value of toString() on the given object matches the
    205      * given text string
    206      *
    207      * @param value the object to be output to the console
    208      * @param expected the expected String representation
    209      */
    210     protected void assertToString(Object value, String expected) {
    211         Object console = InvokerHelper.invokeMethod(value, "toString", null);
    212         assertEquals("toString() on value: " + value, expected, console);
    213     }
    214
    215     /***
    216      * Asserts that the value of inspect() on the given object matches the
    217      * given text string
    218      *
    219      * @param value the object to be output to the console
    220      * @param expected the expected String representation
    221      */
    222     protected void assertInspect(Object value, String expected) {
    223         Object console = InvokerHelper.invokeMethod(value, "inspect", null);
    224         assertEquals("inspect() on value: " + value, expected, console);
    225     }
    226
    227     /***
    228      * Asserts that the script runs without any exceptions
    229      *
    230      * @param script the script that should pass without any exception thrown
    231      */
    232     protected void assertScript(final String script) throws Exception {
    233         log.info("About to execute script");
    234         //log.info(script);
    235
    236         // lets write the file to the target directory so its available
    237         // to the MetaClass.getClassNode()
    238         // the file is also used to determine the CodeSource if running with a security manager
    239         String testClassName = getTestClassName();
    240
    241         File file = new File("target/test-classes/" + testClassName);
    242
    243         log.info("Creating file " + file);
    244
    245         DefaultGroovyMethods.withPrintWriter(file, new Closure(null) {
    246             protected void doCall(PrintWriter writer) {
    247                 writer.println(script);
    248             }
    249         });
    250
    251         GroovyShell shell = new GroovyShell();
    252         shell.evaluate(new GroovyCodeSource(file));
    253     }
    254
    255     protected String getTestClassName() {
    256         return "TestScript" + getMethodName() + (counter++) + ".groovy";
    257     }
    258
    259     /***
    260      * Asserts that the given code closure fails when it is evaluated
    261      *
    262      * @param code
    263      */
    264     protected void shouldFail(Closure code) {
    265         boolean failed = false;
    266         try {
    267             code.call();
    268         }
    269         catch (Exception e) {
    270             failed = true;
    271             System.out.println("Worked: caught expected exception: " + e);
    272         }
    273         assertTrue("Closure " + code + " should have failed", failed);
    274     }
    275
    276     /***
    277      * Asserts that the given code closure fails when it is evaluated
    278      * and that a particular exception is thrown.
    279      *
    280      * @param clazz the class of the expected exception
    281      * @param code the closure that should fail
    282      */
    283     protected void shouldFail(Class clazz, Closure code) {
    284         boolean failed = false;
    285         try {
    286             code.call();
    287         }
    288         catch (Exception e) {
    289             if (clazz.isInstance(e)) {
    290                 failed = true;
    291                 System.out.println("Worked: caught expected exception: " + e);
    292             }
    293         }
    294         assertTrue("Closure " + code + " should have failed with an exception of type " + clazz.getName(), failed);
    295     }
    296
    297
    298     /***
    299      *  Returns a copy of a string in which all EOLs are \n.
    300      */
    301     protected String fixEOLs( String value )
    302     {
    303         return value.replaceAll( "(//r//n?)|\n", "\n" );
    304     }
    305 }