commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r617360 - in /commons/proper/lang/trunk/src: java/org/apache/commons/lang/time/DateUtils.java test/org/apache/commons/lang/time/DateUtilsFragmentTest.java test/org/apache/commons/lang/time/TimeTestSuite.java
Date Fri, 01 Feb 2008 07:12:59 GMT
Author: bayard
Date: Thu Jan 31 23:12:56 2008
New Revision: 617360

URL: http://svn.apache.org/viewvc?rev=617360&view=rev
Log:
Applying my patch from LANG-379, based on Robert Scholte's patch adding the 'getFragment'
family of methods

Added:
    commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
  (with props)
Modified:
    commons/proper/lang/trunk/src/java/org/apache/commons/lang/time/DateUtils.java
    commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/TimeTestSuite.java

Modified: commons/proper/lang/trunk/src/java/org/apache/commons/lang/time/DateUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/java/org/apache/commons/lang/time/DateUtils.java?rev=617360&r1=617359&r2=617360&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/java/org/apache/commons/lang/time/DateUtils.java (original)
+++ commons/proper/lang/trunk/src/java/org/apache/commons/lang/time/DateUtils.java Thu Jan
31 23:12:56 2008
@@ -28,12 +28,23 @@
 /**
  * <p>A suite of utilities surrounding the use of the
  * {@link java.util.Calendar} and {@link java.util.Date} object.</p>
+ * 
+ * <p>DateUtils contains a lot of common methods considering manipulations of Dates
or Calendars.
+ * Some methods require some extra explanation.
+ * The truncate and round methods could be considered the Math.floor(), Math.ceil() or Math.round
versions for dates
+ * This way date-fields will be ignored in bottom-up order.
+ * As a complement to these methods we've introduced some fragment-methods. With these methods
the Date-fields will be ignored in top-down order.
+ * Since a date without a year is not a valid date, you have to decide in what kind of date-field
you want your result, for instance milliseconds or days.
+ * </p>
+ *   
+ *   
  *
  * @author <a href="mailto:sergek@lokitech.com">Serge Knystautas</a>
  * @author Stephen Colebourne
  * @author Janek Bogucki
  * @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a>
  * @author Phil Steitz
+ * @author Robert Scholte
  * @since 2.0
  * @version $Id$
  */
@@ -1035,6 +1046,473 @@
         } else {
             throw new ClassCastException("Could not iterate based on " + focus);
         }
+    }
+    
+    /**
+     * <p>Returns the number of milliseconds within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p>
+     * 
+     * <p>Asking the milliseconds of any date will only return the number of milliseconds
+     * of the current second (resulting in a number between 0 and 999). This 
+     * method will retrieve the number of milliseconds for any fragment. 
+     * For example, if you want to calculate the number of milliseconds past today, 
+     * your fragment is Calendar.DATE or Calendar.DAY_OF_YEAR. The result will
+     * be all milliseconds of the past hour(s), minutes(s) and second(s).</p>
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a SECOND field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.SECOND as fragment will return
538</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.SECOND as fragment will return
538</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10538 (10*1000 + 538)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in milliseconds)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @return number of milliseconds within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInMilliseconds(Date date, int fragment) {
+        return getFragment(date, fragment, Calendar.MILLISECOND);    
+    }
+    
+    /**
+     * <p>Returns the number of seconds within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the seconds of any date will only return the number of seconds
+     * of the current minute (resulting in a number between 0 and 59). This 
+     * method will retrieve the number of seconds for any fragment. 
+     * For example, if you want to calculate the number of seconds past today, 
+     * your fragment is Calendar.DATE or Calendar.DAY_OF_YEAR. The result will
+     * be all seconds of the past hour(s) and minutes(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a SECOND field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10 (equivalent to deprecated date.getSeconds())</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10 (equivalent to deprecated date.getSeconds())</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 26110 (7*3600 + 15*60 + 10)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in seconds)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @return number of seconds within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInSeconds(Date date, int fragment) {
+        return getFragment(date, fragment, Calendar.SECOND);
+    }
+    
+    /**
+     * <p>Returns the number of minutes within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the minutes of any date will only return the number of minutes
+     * of the current hour (resulting in a number between 0 and 59). This 
+     * method will retrieve the number of minutes for any fragment. 
+     * For example, if you want to calculate the number of minutes past this month, 
+     * your fragment is Calendar.MONTH. The result will be all minutes of the 
+     * past day(s) and hour(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a MINUTE field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.HOUR_OF_DAY as fragment will
return 15 (equivalent to deprecated date.getMinutes())</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.HOUR_OF_DAY as fragment will
return 15 (equivalent to deprecated date.getMinutes())</li>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
15</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
435 (7*60 + 15)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in minutes)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @return number of minutes within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInMinutes(Date date, int fragment) {
+        return getFragment(date, fragment, Calendar.MINUTE);
+    }
+    
+    /**
+     * <p>Returns the number of hours within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the hours of any date will only return the number of hours
+     * of the current day (resulting in a number between 0 and 23). This 
+     * method will retrieve the number of hours for any fragment. 
+     * For example, if you want to calculate the number of hours past this month, 
+     * your fragment is Calendar.MONTH. The result will be all hours of the 
+     * past day(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a HOUR field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 7 (equivalent to deprecated date.getHours())</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 7 (equivalent to deprecated date.getHours())</li>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
7</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
127 (5*24 + 7)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in hours)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @return number of hours within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInHours(Date date, int fragment) {
+        return getFragment(date, fragment, Calendar.HOUR_OF_DAY);
+    }
+    
+    /**
+     * <p>Returns the number of days within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the days of any date will only return the number of days
+     * of the current month (resulting in a number between 1 and 31). This 
+     * method will retrieve the number of days for any fragment. 
+     * For example, if you want to calculate the number of days past this year, 
+     * your fragment is Calendar.YEAR. The result will be all days of the 
+     * past month(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a DAY field will return 0.</p> 
+     *  
+     * <p>
+     * <ul>
+     *  <li>January 28, 2008 with Calendar.MONTH as fragment will return 28 (equivalent
to deprecated date.getDay())</li>
+     *  <li>February 28, 2008 with Calendar.MONTH as fragment will return 28 (equivalent
to deprecated date.getDay())</li>
+     *  <li>January 28, 2008 with Calendar.YEAR as fragment will return 28</li>
+     *  <li>February 28, 2008 with Calendar.YEAR as fragment will return 59</li>
+     *  <li>January 28, 2008 with Calendar.MILLISECOND as fragment will return 0 (a
millisecond cannot be split in days)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @return number of days  within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInDays(Date date, int fragment) {
+        return getFragment(date, fragment, Calendar.DAY_OF_YEAR);
+    }
+
+    /**
+     * <p>Returns the number of milliseconds within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the milliseconds of any date will only return the number of milliseconds
+     * of the current second (resulting in a number between 0 and 999). This 
+     * method will retrieve the number of milliseconds for any fragment. 
+     * For example, if you want to calculate the number of seconds past today, 
+     * your fragment is Calendar.DATE or Calendar.DAY_OF_YEAR. The result will
+     * be all seconds of the past hour(s), minutes(s) and second(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a MILLISECOND field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.SECOND as fragment will return
538 (equivalent to calendar.get(Calendar.MILLISECOND))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.SECOND as fragment will return
538 (equivalent to calendar.get(Calendar.MILLISECOND))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10538 (10*1000 + 538)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in milliseconds)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @return number of milliseconds within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+  public static long getFragmentInMilliseconds(Calendar calendar, int fragment) {
+    return getFragment(calendar, fragment, Calendar.MILLISECOND);
+  }
+    /**
+     * <p>Returns the number of seconds within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the seconds of any date will only return the number of seconds
+     * of the current minute (resulting in a number between 0 and 59). This 
+     * method will retrieve the number of seconds for any fragment. 
+     * For example, if you want to calculate the number of seconds past today, 
+     * your fragment is Calendar.DATE or Calendar.DAY_OF_YEAR. The result will
+     * be all seconds of the past hour(s) and minutes(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a SECOND field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10 (equivalent to calendar.get(Calendar.SECOND))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MINUTE as fragment will return
10 (equivalent to calendar.get(Calendar.SECOND))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 26110 (7*3600 + 15*60 + 10)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in seconds)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @return number of seconds within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInSeconds(Calendar calendar, int fragment) {
+        return getFragment(calendar, fragment, Calendar.SECOND);
+    }
+    
+    /**
+     * <p>Returns the number of minutes within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the minutes of any date will only return the number of minutes
+     * of the current hour (resulting in a number between 0 and 59). This 
+     * method will retrieve the number of minutes for any fragment. 
+     * For example, if you want to calculate the number of minutes past this month, 
+     * your fragment is Calendar.MONTH. The result will be all minutes of the 
+     * past day(s) and hour(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a MINUTE field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.HOUR_OF_DAY as fragment will
return 15 (equivalent to calendar.get(Calendar.MINUTES))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.HOUR_OF_DAY as fragment will
return 15 (equivalent to calendar.get(Calendar.MINUTES))</li>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
15</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
435 (7*60 + 15)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in minutes)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @return number of minutes within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInMinutes(Calendar calendar, int fragment) {
+        return getFragment(calendar, fragment, Calendar.MINUTE);
+    }
+    
+    /**
+     * <p>Returns the number of hours within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the hours of any date will only return the number of hours
+     * of the current day (resulting in a number between 0 and 23). This 
+     * method will retrieve the number of hours for any fragment. 
+     * For example, if you want to calculate the number of hours past this month, 
+     * your fragment is Calendar.MONTH. The result will be all hours of the 
+     * past day(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a HOUR field will return 0.</p> 
+     *  
+     * <p>
+     * <ul>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 7 (equivalent to calendar.get(Calendar.HOUR_OF_DAY))</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.DAY_OF_YEAR as fragment will
return 7 (equivalent to calendar.get(Calendar.HOUR_OF_DAY))</li>
+     *  <li>January 1, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
7</li>
+     *  <li>January 6, 2008 7:15:10.538 with Calendar.MONTH as fragment will return
127 (5*24 + 7)</li>
+     *  <li>January 16, 2008 7:15:10.538 with Calendar.MILLISECOND as fragment will
return 0 (a millisecond cannot be split in hours)</li>
+     * </ul>
+     * </p>
+     *  
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @return number of hours within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInHours(Calendar calendar, int fragment) {
+        return getFragment(calendar, fragment, Calendar.HOUR_OF_DAY);
+    }
+    
+    /**
+     * <p>Returns the number of days within the 
+     * fragment. All datefields greater than the fragment will be ignored.</p> 
+     * 
+     * <p>Asking the days of any date will only return the number of days
+     * of the current month (resulting in a number between 1 and 31). This 
+     * method will retrieve the number of days for any fragment. 
+     * For example, if you want to calculate the number of days past this year, 
+     * your fragment is Calendar.YEAR. The result will be all days of the 
+     * past month(s).</p> 
+     * 
+     * <p>Valid fragments are: Calendar.YEAR, Calendar.MONTH, both 
+     * Calendar.DAY_OF_YEAR and Calendar.DATE, Calendar.HOUR_OF_DAY, 
+     * Calendar.MINUTE, Calendar.SECOND and Calendar.MILLISECOND
+     * A fragment less than or equal to a DAY field will return 0.</p> 
+     * 
+     * <p>
+     * <ul>
+     *  <li>January 28, 2008 with Calendar.MONTH as fragment will return 28 (equivalent
to calendar.get(Calendar.DAY_OF_MONTH))</li>
+     *  <li>February 28, 2008 with Calendar.MONTH as fragment will return 28 (equivalent
to calendar.get(Calendar.DAY_OF_MONTH))</li>
+     *  <li>January 28, 2008 with Calendar.YEAR as fragment will return 28 (equivalent
to calendar.get(Calendar.DAY_OF_YEAR))</li>
+     *  <li>February 28, 2008 with Calendar.YEAR as fragment will return 59 (equivalent
to calendar.get(Calendar.DAY_OF_YEAR))</li>
+     *  <li>January 28, 2008 with Calendar.MILLISECOND as fragment will return 0 (a
millisecond cannot be split in days)</li>
+     * </ul>
+     * </p>
+     * 
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @return number of days within the fragment of date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    public static long getFragmentInDays(Calendar calendar, int fragment) {
+        return getFragment(calendar, fragment, Calendar.DAY_OF_YEAR);
+    }
+    
+    /**
+     * Date-version for fragment-calculation in any unit
+     * 
+     * @param date the date to work with, not null
+     * @param fragment the Calendar field part of date to calculate 
+     * @param unit Calendar field defining the unit
+     * @return number of units within the fragment of the date
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    private static long getFragment(Date date, int fragment, int unit) {
+        if(date == null) {
+            throw  new IllegalArgumentException("The date must not be null");
+        }
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        return getFragment(calendar, fragment, unit);
+    }
+
+    /**
+     * Calendar-version for fragment-calculation in any unit
+     * 
+     * @param calendar the calendar to work with, not null
+     * @param fragment the Calendar field part of calendar to calculate 
+     * @param unit Calendar field defining the unit
+     * @return number of units within the fragment of the calendar
+     * @throws IllegalArgumentException if the date is <code>null</code> or 
+     * fragment is not supported
+     * @since 2.4
+     */
+    private static long getFragment(Calendar calendar, int fragment, int unit) {
+        if(calendar == null) {
+            throw  new IllegalArgumentException("The date must not be null"); 
+        }
+        long millisPerUnit = getMillisPerUnit(unit);
+        long result = 0;
+        
+        // Fragments bigger than a day require a breakdown to days
+        switch (fragment) {
+            case Calendar.YEAR:
+                result += (calendar.get(Calendar.DAY_OF_YEAR) * MILLIS_PER_DAY) / millisPerUnit;
+                break;
+            case Calendar.MONTH:
+                result += (calendar.get(Calendar.DAY_OF_MONTH) * MILLIS_PER_DAY) / millisPerUnit;
+                break;
+        }
+
+        switch (fragment) {
+            // Number of days already calculated for these cases
+            case Calendar.YEAR:
+            case Calendar.MONTH:
+            
+            // The rest of the valid cases
+            case Calendar.DAY_OF_YEAR:
+            case Calendar.DATE:
+                result += (calendar.get(Calendar.HOUR_OF_DAY) * MILLIS_PER_HOUR) / millisPerUnit;
+            case Calendar.HOUR_OF_DAY:
+                result += (calendar.get(Calendar.MINUTE) * MILLIS_PER_MINUTE) / millisPerUnit;
+            case Calendar.MINUTE:
+                result += (calendar.get(Calendar.SECOND) * MILLIS_PER_SECOND) / millisPerUnit;
+            case Calendar.SECOND:
+                result += (calendar.get(Calendar.MILLISECOND) * 1) / millisPerUnit;
+                break;
+            case Calendar.MILLISECOND: break;//never useful
+                default: throw new IllegalArgumentException("The fragment " + fragment +
" is not supported");
+        }
+        return result;
+    }
+    
+    /**
+     * Returns the number of millis of a datefield, if this is a constant value
+     * 
+     * @param unit A Calendar field which is a valid unit for a fragment
+     * @return number of millis
+     * @throws IllegalArgumentException if date can't be represented in millisenconds
+     * @since 2.4 
+     */
+    private static long getMillisPerUnit(int unit) {
+        long result = Long.MAX_VALUE;
+        switch (unit) {
+            case Calendar.DAY_OF_YEAR:
+            case Calendar.DATE:
+                result = MILLIS_PER_DAY;
+                break;
+            case Calendar.HOUR_OF_DAY:
+                result = MILLIS_PER_HOUR;
+                break;
+            case Calendar.MINUTE:
+                result = MILLIS_PER_MINUTE;
+                break;
+            case Calendar.SECOND:
+                result = MILLIS_PER_SECOND;
+                break;
+            case Calendar.MILLISECOND:
+                result = 1;
+                break;
+            default: throw new IllegalArgumentException("The unit " + unit + " cannot be
represented is milleseconds");
+        }
+        return result;
     }
 
     /**

Added: commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java?rev=617360&view=auto
==============================================================================
--- commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
(added)
+++ commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
Thu Jan 31 23:12:56 2008
@@ -0,0 +1,491 @@
+package org.apache.commons.lang.time;
+
+import java.util.Calendar;
+import java.util.Date;
+
+import junit.framework.TestCase;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.time.DateFormatUtils;
+
+public class DateUtilsFragmentTest extends TestCase {
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite(DateUtilsFragmentTest.class);
+        suite.setName("DateUtils Fragment Tests");
+        return suite;
+    }
+
+	private static final int months = 7;   // second final prime before 12
+	private static final int days = 23;    // second final prime before 31 (and valid)
+	private static final int hours = 19;   // second final prime before 24
+	private static final int minutes = 53; // second final prime before 60
+	private static final int seconds = 47; // third final prime before 60
+	private static final int millis = 991; // second final prime before 1000
+
+	private Date aDate;
+	private Calendar aCalendar;
+
+	protected void setUp() {
+		aCalendar = Calendar.getInstance();
+		aCalendar.set(2005, months, days, hours, minutes, seconds);
+		aCalendar.set(Calendar.MILLISECOND, millis);
+		aDate = aCalendar.getTime();
+	}
+	
+	public void testNullDate() {
+		try {
+			DateUtils.getFragmentInMilliseconds((Date) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInSeconds((Date) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInMinutes((Date) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInHours((Date) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInDays((Date) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+	}
+
+	public void testNullCalendar() {
+		try {
+			DateUtils.getFragmentInMilliseconds((Calendar) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInSeconds((Calendar) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInMinutes((Calendar) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInHours((Calendar) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInDays((Calendar) null, Calendar.MILLISECOND);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+	}
+	
+	public void testInvalidFragmentWithDate() {
+		try {
+			DateUtils.getFragmentInMilliseconds(aDate, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInSeconds(aDate, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInMinutes(aDate, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInHours(aDate, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInDays(aDate, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+	}
+
+	public void testInvalidFragmentWithCalendar() {
+		try {
+			DateUtils.getFragmentInMilliseconds(aCalendar, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInSeconds(aCalendar, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInMinutes(aCalendar, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInHours(aCalendar, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+
+		try {
+			DateUtils.getFragmentInDays(aCalendar, 0);
+			fail();
+		} catch(IllegalArgumentException iae) {}
+	}
+
+	public void testMillisecondFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInMilliseconds(aDate, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MILLISECOND));
+	}
+
+	public void testMillisecondFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MILLISECOND));
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MILLISECOND));
+	}
+	
+	public void testSecondFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInSeconds(aDate, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.SECOND));
+	}
+
+	public void testSecondFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInSeconds(aCalendar, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.SECOND));
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.SECOND));
+	}
+	
+	public void testMinuteFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInMinutes(aDate, Calendar.MINUTE));
+		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.MINUTE));
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.MINUTE));
+	}
+
+	public void testMinuteFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInMinutes(aCalendar, Calendar.MINUTE));
+		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.MINUTE));
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.MINUTE));
+	}
+
+	public void testHourOfDayFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInHours(aDate, Calendar.HOUR_OF_DAY));
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.HOUR_OF_DAY));
+	}
+
+	public void testHourOfDayFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInHours(aCalendar, Calendar.HOUR_OF_DAY));
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.HOUR_OF_DAY));
+	}
+
+	public void testDayOfYearFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DAY_OF_YEAR));
+	}
+
+	public void testDayOfYearFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DAY_OF_YEAR));
+	}
+
+	public void testDateFragmentInLargerUnitWithDate() {
+		assertEquals(0, DateUtils.getFragmentInDays(aDate, Calendar.DATE));
+	}
+
+	public void testDateFragmentInLargerUnitWithCalendar() {
+		assertEquals(0, DateUtils.getFragmentInDays(aCalendar, Calendar.DATE));
+	}
+
+	//Calendar.SECOND as useful fragment
+	
+	public void testMillisecondsOfSecondWithDate() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.SECOND);
+		assertEquals(millis, testResult);
+	}
+
+	public void testMillisecondsOfSecondWithCalendar() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.SECOND);
+		assertEquals(millis, testResult);
+		assertEquals(aCalendar.get(Calendar.MILLISECOND), testResult);
+	}
+
+	//Calendar.MINUTE as useful fragment
+
+	public void testMillisecondsOfMinuteWithDate() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MINUTE);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
+	}
+
+	public void testMillisecondsOfMinuteWithCalender() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MINUTE);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND), testResult);
+	}
+
+	public void testSecondsofMinuteWithDate() {
+		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MINUTE);
+		assertEquals(seconds, testResult);
+	}
+
+	public void testSecondsofMinuteWithCalendar() {
+		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MINUTE);
+		assertEquals(seconds, testResult);
+		assertEquals(aCalendar.get(Calendar.SECOND), testResult);
+	}
+
+	//Calendar.HOUR_OF_DAY as useful fragment
+	
+	public void testMillisecondsOfHourWithDate() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.HOUR_OF_DAY);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE),
testResult);
+	}
+	
+	public void testMillisecondsOfHourWithCalendar() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.HOUR_OF_DAY);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE),
testResult);
+	}
+
+	public void testSecondsofHourWithDate() {
+		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.HOUR_OF_DAY);
+		assertEquals(
+				seconds
+						+ (minutes
+								* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
+				testResult);
+	}
+
+	public void testSecondsofHourWithCalendar() {
+		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.HOUR_OF_DAY);
+		assertEquals(
+				seconds
+						+ (minutes
+								* DateUtils.MILLIS_PER_MINUTE / DateUtils.MILLIS_PER_SECOND),
+				testResult);
+	}
+
+	public void testMinutesOfHourWithDate() {
+		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.HOUR_OF_DAY);
+		assertEquals(minutes, testResult);
+	}
+
+	public void testMinutesOfHourWithCalendar() {
+		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.HOUR_OF_DAY);
+		assertEquals(minutes, testResult);
+	}
+
+	//Calendar.DATE and Calendar.DAY_OF_YEAR as useful fragment
+	public void testMillisecondsOfDayWithDate() {
+		long testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DATE);
+		long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR); 
+		assertEquals(expectedValue, testresult);
+		testresult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testresult);
+	}
+	
+	public void testMillisecondsOfDayWithCalendar() {
+		long testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DATE);
+		long expectedValue = millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+ (hours * DateUtils.MILLIS_PER_HOUR); 
+		assertEquals(expectedValue, testresult);
+		testresult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testresult);
+	}
+
+	public void testSecondsOfDayWithDate() {
+		long testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DATE);
+		long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/
DateUtils.MILLIS_PER_SECOND;
+		assertEquals(expectedValue, testresult);
+		testresult = DateUtils.getFragmentInSeconds(aDate, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testresult);
+	}
+
+	public void testSecondsOfDayWithCalendar() {
+		long testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DATE);
+		long expectedValue = seconds + ((minutes * DateUtils.MILLIS_PER_MINUTE) + (hours * DateUtils.MILLIS_PER_HOUR))/
DateUtils.MILLIS_PER_SECOND;
+		assertEquals(expectedValue, testresult);
+		testresult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testresult);
+	}
+
+	public void testMinutesOfDayWithDate() {
+		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DATE);
+		long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;

+		assertEquals(expectedValue,testResult);
+		testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue,testResult);
+	}
+
+	public void testMinutesOfDayWithCalendar() {
+		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DATE);
+		long expectedValue = minutes + ((hours * DateUtils.MILLIS_PER_HOUR))/ DateUtils.MILLIS_PER_MINUTE;

+		assertEquals(expectedValue, testResult);
+		testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testResult);
+	}
+	
+	public void testHoursOfDayWithDate() {
+		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.DATE);
+		long expectedValue = hours; 
+		assertEquals(expectedValue,testResult);
+		testResult = DateUtils.getFragmentInHours(aDate, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue,testResult);
+	}
+
+	public void testHoursOfDayWithCalendar() {
+		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DATE);
+		long expectedValue = hours; 
+		assertEquals(expectedValue, testResult);
+		testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.DAY_OF_YEAR);
+		assertEquals(expectedValue, testResult);
+	}
+	
+	
+	//Calendar.MONTH as useful fragment
+	public void testMillisecondsOfMonthWithDate() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.MONTH);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
+				testResult);
+	}
+
+	public void testMillisecondsOfMonthWithCalendar() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.MONTH);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+				+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY),
+testResult);
+	}
+	
+	public void testSecondsOfMonthWithDate() {
+		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.MONTH);
+		assertEquals(
+				seconds
+						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_SECOND,
+				testResult);
+	}
+
+	public void testSecondsOfMonthWithCalendar() {
+		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.MONTH);
+		assertEquals(
+				seconds
+						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_SECOND,
+				testResult);
+	}
+
+	public void testMinutesOfMonthWithDate() {
+		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.MONTH);
+		assertEquals(minutes
+								+ ((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_MINUTE,
+				testResult);
+	}
+
+	public void testMinutesOfMonthWithCalendar() {
+		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.MONTH);
+		assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_MINUTE,
+				testResult);
+	}
+
+	public void testHoursOfMonthWithDate() {
+		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.MONTH);
+		assertEquals(hours + ((days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_HOUR,
+				testResult);
+	}
+
+	public void testHoursOfMonthWithCalendar() {
+		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.MONTH);
+		assertEquals( hours +((days * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_HOUR,
+				testResult);
+	}
+	
+	//Calendar.YEAR as useful fragment
+	public void testMillisecondsOfYearWithDate() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aDate, Calendar.YEAR);
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(aDate);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
+				testResult);
+	}
+
+	public void testMillisecondsOfYearWithCalendar() {
+		long testResult = DateUtils.getFragmentInMilliseconds(aCalendar, Calendar.YEAR);
+		assertEquals(millis + (seconds * DateUtils.MILLIS_PER_SECOND) + (minutes * DateUtils.MILLIS_PER_MINUTE)
+				+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY),
+testResult);
+	}
+	
+	public void testSecondsOfYearWithDate() {
+		long testResult = DateUtils.getFragmentInSeconds(aDate, Calendar.YEAR);
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(aDate);
+		assertEquals(
+				seconds
+						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_SECOND,
+				testResult);
+	}
+
+	public void testSecondsOfYearWithCalendar() {
+		long testResult = DateUtils.getFragmentInSeconds(aCalendar, Calendar.YEAR);
+		assertEquals(
+				seconds
+						+ ((minutes * DateUtils.MILLIS_PER_MINUTE)
+								+ (hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_SECOND,
+				testResult);
+	}
+
+	public void testMinutesOfYearWithDate() {
+		long testResult = DateUtils.getFragmentInMinutes(aDate, Calendar.YEAR);
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(aDate);
+		assertEquals(minutes
+								+ ((hours * DateUtils.MILLIS_PER_HOUR) + (cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_MINUTE,
+				testResult);
+	}
+
+	public void testMinutesOfYearWithCalendar() {
+		long testResult = DateUtils.getFragmentInMinutes(aCalendar, Calendar.YEAR);
+		assertEquals( minutes  +((hours * DateUtils.MILLIS_PER_HOUR) + (aCalendar.get(Calendar.DAY_OF_YEAR)
* DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_MINUTE,
+				testResult);
+	}
+
+	public void testHoursOfYearWithDate() {
+		long testResult = DateUtils.getFragmentInHours(aDate, Calendar.YEAR);
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(aDate);
+		assertEquals(hours + ((cal.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_HOUR,
+				testResult);
+	}
+
+	public void testHoursOfYearWithCalendar() {
+		long testResult = DateUtils.getFragmentInHours(aCalendar, Calendar.YEAR);
+		assertEquals( hours +((aCalendar.get(Calendar.DAY_OF_YEAR) * DateUtils.MILLIS_PER_DAY))
+						/ DateUtils.MILLIS_PER_HOUR,
+				testResult);
+	}
+}

Propchange: commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/DateUtilsFragmentTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/TimeTestSuite.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/TimeTestSuite.java?rev=617360&r1=617359&r2=617360&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/TimeTestSuite.java (original)
+++ commons/proper/lang/trunk/src/test/org/apache/commons/lang/time/TimeTestSuite.java Thu
Jan 31 23:12:56 2008
@@ -54,6 +54,7 @@
         suite.addTest(DurationFormatUtilsTest.suite());
         suite.addTest(StopWatchTest.suite());
         suite.addTest(FastDateFormatTest.suite());
+        suite.addTest(DateUtilsFragmentTest.suite());
         return suite;
     }
 }



Mime
View raw message