Coverage report

  %line %branch
org.apache.commons.mail.EmailUtils
72% 
98% 

 1   
 /*
 2   
  * Copyright 2001-2005 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   
 
 17   
 package org.apache.commons.mail;
 18   
 
 19   
 import java.util.Random;
 20   
 
 21   
 /**
 22   
  * Utility methods used by commons-email.
 23   
  *
 24   
  * <p>
 25   
  * These methods are copied from other commons components (commons-lang) to avoid creating a dependency for such a small component.
 26   
  * </p>
 27   
  *
 28   
  * <p>
 29   
  * This is a package scoped class, and should not be used directly by users.
 30   
  * </p>
 31   
  *
 32   
  * @author jakarta-commons
 33   
  * @version $Id: EmailUtils.java 279313 2005-09-07 12:41:58Z henning $
 34   
  *
 35   
  * @since 1.0
 36   
  */
 37   
 final class EmailUtils
 38   
 {
 39   
     /**
 40   
      * <p>
 41   
      * Random object used by random method. This has to be not local to the random method so as to not return the same value in the
 42   
      * same millisecond.
 43   
      * </p>
 44   
      */
 45  36 
     private static final Random RANDOM = new Random();
 46   
 
 47   
     /**
 48   
      * Constructs a new <code>EmailException</code> with no detail message.
 49   
      */
 50   
     private EmailUtils()
 51   
     {
 52  0 
         super();
 53  0 
     }
 54   
 
 55   
     /**
 56   
      * <p>
 57   
      * Checks if a String is empty ("") or null.
 58   
      * </p>
 59   
      *
 60   
      * @param str the String to check, may be null
 61   
      *
 62   
      * @return <code>true</code> if the String is empty or null
 63   
      *
 64   
      * @since Commons Lang v2.1, svn 240418
 65   
      */
 66   
     static boolean isEmpty(String str)
 67   
     {
 68  2064 
         return (str == null) || (str.length() == 0);
 69   
     }
 70   
 
 71   
     /**
 72   
      * <p>
 73   
      * Checks if a String is not empty ("") and not null.
 74   
      * </p>
 75   
      *
 76   
      * @param str the String to check, may be null
 77   
      *
 78   
      * @return <code>true</code> if the String is not empty and not null
 79   
      *
 80   
      * @since Commons Lang v2.1, svn 240418
 81   
      */
 82   
     static boolean isNotEmpty(String str)
 83   
     {
 84  798 
         return (str != null) && (str.length() > 0);
 85   
     }
 86   
 
 87   
     /**
 88   
      * <p>
 89   
      * Validate an argument, throwing <code>IllegalArgumentException</code> if the argument is <code>null</code>.
 90   
      * </p>
 91   
      *
 92   
      * @param object the object to check is not <code>null</code>
 93   
      * @param message the exception message you would like to see if the object is <code>null</code>
 94   
      *
 95   
      * @throws IllegalArgumentException if the object is <code>null</code>
 96   
      *
 97   
      * @since Commons Lang v2.1, svn 201930
 98   
      */
 99   
     static void notNull(Object object, String message)
 100   
     {
 101  60 
         if (object == null)
 102   
         {
 103  0 
             throw new IllegalArgumentException(message);
 104   
         }
 105  60 
     }
 106   
 
 107   
     /**
 108   
      * <p>
 109   
      * Creates a random string whose length is the number of characters specified.
 110   
      * </p>
 111   
      *
 112   
      * <p>
 113   
      * Characters will be chosen from the set of alphabetic characters.
 114   
      * </p>
 115   
      *
 116   
      * @param count the length of random string to create
 117   
      *
 118   
      * @return the random string
 119   
      *
 120   
      * @since Commons Lang v2.1, svn 201930
 121   
      */
 122   
     static String randomAlphabetic(int count)
 123   
     {
 124  24 
         return random(count, 0, 0, true, false, null, RANDOM);
 125   
     }
 126   
 
 127   
     /**
 128   
      * <p>
 129   
      * Creates a random string based on a variety of options, using supplied source of randomness.
 130   
      * </p>
 131   
      *
 132   
      * <p>
 133   
      * If start and end are both <code>0</code>, start and end are set to <code>' '</code> and <code>'z'</code>, the ASCII
 134   
      * printable characters, will be used, unless letters and numbers are both <code>false</code>, in which case, start and end
 135   
      * are set to <code>0</code> and <code>Integer.MAX_VALUE</code>.
 136   
      * </p>
 137   
      *
 138   
      * <p>
 139   
      * If set is not <code>null</code>, characters between start and end are chosen.
 140   
      * </p>
 141   
      *
 142   
      * <p>
 143   
      * This method accepts a user-supplied {@link Random} instance to use as a source of randomness. By seeding a single {@link
 144   
      * Random} instance with a fixed seed and using it for each call, the same random sequence of strings can be generated
 145   
      * repeatedly and predictably.
 146   
      * </p>
 147   
      *
 148   
      * @param count the length of random string to create
 149   
      * @param start the position in set of chars to start at
 150   
      * @param end the position in set of chars to end before
 151   
      * @param letters only allow letters?
 152   
      * @param numbers only allow numbers?
 153   
      * @param chars the set of chars to choose randoms from. If <code>null</code>, then it will use the set of all chars.
 154   
      * @param random a source of randomness.
 155   
      *
 156   
      * @return the random string
 157   
      *
 158   
      * @throws IllegalArgumentException if <code>count</code> &lt; 0.
 159   
      *
 160   
      * @since Commons Lang v2.1, svn 201930
 161   
      */
 162   
     private static String random(int count, class="keyword">int start, class="keyword">int end, boolean letters, boolean numbers, char [] chars, Random random)
 163   
     {
 164  24 
         if (count == 0)
 165   
         {
 166  0 
             return "";
 167   
         }
 168  24 
         else if (count < 0)
 169   
         {
 170  0 
             throw new IllegalArgumentException("Requested random string length " + count + " is less than 0.");
 171   
         }
 172   
 
 173  24 
         if ((start == 0) && (end == 0))
 174   
         {
 175  24 
             end = 'z' + 1;
 176  24 
             start = ' ';
 177   
 
 178  24 
             if (!letters && !numbers)
 179   
             {
 180  0 
                 start = 0;
 181  0 
                 end = Integer.MAX_VALUE;
 182   
             }
 183   
         }
 184   
 
 185  24 
         StringBuffer buffer = new StringBuffer();
 186  24 
         int gap = end - start;
 187   
 
 188  480 
         while (count-- != 0)
 189   
         {
 190   
             char ch;
 191   
 
 192  448 
             if (chars == null)
 193   
             {
 194  448 
                 ch = (char) (random.nextInt(gap) + start);
 195   
             }
 196   
             else
 197   
             {
 198  0 
                 ch = chars[random.nextInt(gap) + start];
 199   
             }
 200   
 
 201  448 
             if ((letters && numbers && Character.isLetterOrDigit(ch)) || (letters && Character.isLetter(ch))
 202   
                             || (numbers && Character.isDigit(ch)) || (!letters && !numbers))
 203   
             {
 204  240 
                 buffer.append(ch);
 205   
             }
 206   
             else
 207   
             {
 208  208 
                 count++;
 209   
             }
 210   
         }
 211   
 
 212  24 
         return buffer.toString();
 213   
     }
 214   
 }

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