Coverage report

  %line %branch
org.apache.commons.jelly.tags.junit.AssertThrowsTag
90% 
97% 

 1  
 /*
 2  
  * Copyright 2002,2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *      http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 package org.apache.commons.jelly.tags.junit;
 17  
 
 18  
 import org.apache.commons.jelly.JellyException;
 19  
 import org.apache.commons.jelly.JellyTagException;
 20  
 import org.apache.commons.jelly.XMLOutput;
 21  
 import org.apache.commons.jelly.util.ClassLoaderUtils;
 22  
 import org.apache.commons.logging.Log;
 23  
 import org.apache.commons.logging.LogFactory;
 24  
 
 25  
 /**
 26  
  * Runs its body and asserts that an exception is thrown by it.  If no
 27  
  * exception is thrown the tag fails.  By default all exceptions are caught.
 28  
  * If however <code>expected</code> was specified the body must throw
 29  
  * an exception of the given class, otherwise the assertion fails.  The
 30  
  * exception thrown by the body can also be of any subtype of the specified
 31  
  * exception class.  The optional <code>var</code> attribute can be specified if
 32  
  * the caught exception is to be exported to a variable.
 33  
  */
 34  9
 public class AssertThrowsTag extends AssertTagSupport {
 35  
 
 36  
     /** The Log to which logging calls will be made. */
 37  1
     private static final Log log = LogFactory.getLog(AssertThrowsTag.class);
 38  
 
 39  
     /**
 40  
      * The variable name to export the caught exception to.
 41  
      */
 42  
     private String var;
 43  
 
 44  
     /**
 45  
      * The class name (fully qualified) of the exception expected to be thrown
 46  
      * by the body.  Also a superclass of the expected exception can be given.
 47  
      */
 48  
     private String expected;
 49  
 
 50  
     /**
 51  
      * Sets the ClassLoader to be used when loading an exception class
 52  
      */
 53  
     private ClassLoader classLoader;
 54  
 
 55  
     // Tag interface
 56  
     //-------------------------------------------------------------------------
 57  
     public void doTag(XMLOutput output) throws JellyTagException {
 58  7
         Class throwableClass = null;
 59  
         try {
 60  7
              throwableClass = getThrowableClass();
 61  6
         } catch (ClassNotFoundException e) {
 62  1
             throw new JellyTagException(e);
 63  
         }
 64  
 
 65  
         try {
 66  6
             invokeBody(output);
 67  1
         }
 68  
         catch (Throwable t) {
 69  5
             if (t instanceof JellyException) {
 70  
                 // unwrap Jelly exceptions which wrap other exceptions
 71  5
                 JellyException je = (JellyException) t;
 72  5
                 if (je.getCause() != null) {
 73  5
                     t = je.getCause();
 74  
                 }
 75  
             }
 76  5
             if (var != null) {
 77  1
                 context.setVariable(var, t);
 78  
             }
 79  5
             if (throwableClass != null && !throwableClass.isAssignableFrom(t.getClass())) {
 80  1
                 fail("Unexpected exception: " + t);
 81  
             }
 82  
             else {
 83  4
                 return;
 84  
             }
 85  
         }
 86  1
         fail("No exception was thrown.");
 87  0
     }
 88  
 
 89  
     // Properties
 90  
     //-------------------------------------------------------------------------
 91  
     /**
 92  
      * Sets the class name of exception expected to be thrown by the body.  The
 93  
      * class name must be fully qualified and can either be the expected
 94  
      * exception class itself or any supertype of it, but must be a subtype of
 95  
      * <code>java.lang.Throwable</code>.
 96  
      */
 97  
     public void setExpected(String expected) {
 98  5
         this.expected = expected;
 99  5
     }
 100  
 
 101  
     /**
 102  
      * Sets the variable name to define for this expression.
 103  
      */
 104  
     public void setVar(String var) {
 105  1
         this.var = class="keyword">var;
 106  1
     }
 107  
 
 108  
     /**
 109  
      * Sets the class loader to be used to load the exception type
 110  
      */
 111  
     public void setClassLoader(ClassLoader classLoader) {
 112  0
         this.classLoader = classLoader;
 113  0
     }
 114  
 
 115  
     public ClassLoader getClassLoader() {
 116  5
         return ClassLoaderUtils.getClassLoader(classLoader, getContext().getUseContextClassLoader(), getClass());
 117  
     }
 118  
 
 119  
     // Implementation methods
 120  
     //-------------------------------------------------------------------------
 121  
 
 122  
     /**
 123  
      * Returns the <code>Class</code> corresponding to the class
 124  
      * specified by <code>expected</code>. If
 125  
      * <code>expected</code> was either not specified then <code>java. lang.
 126  
      * Throwable</code> is returned.
 127  
      * Otherwise if the class couldn't be
 128  
      * found or doesn't denote an exception class then an exception is thrown.
 129  
      *
 130  
      * @return Class The class of the exception to expect
 131  
      */
 132  
     protected Class getThrowableClass() throws ClassNotFoundException {
 133  7
         if (expected == null) {
 134  2
             return Throwable.class;
 135  
         }
 136  
 
 137  5
         Class throwableClass = null;
 138  
         try {
 139  5
             throwableClass = getClassLoader().loadClass(expected);
 140  4
         }
 141  
         catch (ClassNotFoundException e) {
 142  1
             try {
 143  1
                 throwableClass = Thread.currentThread().getContextClassLoader().loadClass(expected);
 144  0
             }
 145  
             catch (ClassNotFoundException e2) {
 146  1
                 log.warn( "Could not find exception class: " + expected );
 147  1
                 throw e;
 148  
             }
 149  
         }
 150  
 
 151  4
         if (!Throwable.class.isAssignableFrom(throwableClass)) {
 152  1
             log.warn( "The class: " + expected + " is not an Exception class.");
 153  1
             return null;
 154  
         }
 155  3
         return throwableClass;
 156  
     }
 157  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.