Coverage report

  %line %branch
org.apache.commons.mail.EmailUtils
0% 
0% 

 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  0
     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  0
         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  0
         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  0
         if (object == null)
 102  
         {
 103  0
             throw new IllegalArgumentException(message);
 104  
         }
 105  0
     }
 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  0
         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  0
         if (count == 0)
 165  
         {
 166  0
             return "";
 167  
         }
 168  0
         else if (count < 0)
 169  
         {
 170  0
             throw new IllegalArgumentException("Requested random string length " + count + " is less than 0.");
 171  
         }
 172  
 
 173  0
         if ((start == 0) && (end == 0))
 174  
         {
 175  0
             end = 'z' + 1;
 176  0
             start = ' ';
 177  
 
 178  0
             if (!letters && !numbers)
 179  
             {
 180  0
                 start = 0;
 181  0
                 end = Integer.MAX_VALUE;
 182  
             }
 183  
         }
 184  
 
 185  0
         StringBuffer buffer = new StringBuffer();
 186  0
         int gap = end - start;
 187  
 
 188  0
         while (count-- != 0)
 189  
         {
 190  
             char ch;
 191  
 
 192  0
             if (chars == null)
 193  
             {
 194  0
                 ch = (char) (random.nextInt(gap) + start);
 195  
             }
 196  
             else
 197  
             {
 198  0
                 ch = chars[random.nextInt(gap) + start];
 199  
             }
 200  
 
 201  0
             if ((letters && numbers && Character.isLetterOrDigit(ch)) || (letters && Character.isLetter(ch))
 202  
                             || (numbers && Character.isDigit(ch)) || (!letters && !numbers))
 203  
             {
 204  0
                 buffer.append(ch);
 205  
             }
 206  
             else
 207  
             {
 208  0
                 count++;
 209  
             }
 210  0
         }
 211  
 
 212  0
         return buffer.toString();
 213  
     }
 214  
 }

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