Port EventRecurrence.parse() from native

This adds a Java-language implementation of EventRecurrence.parse(),
to make it easier to relocate it for the benefit of unbundled
Calendar.

Differences from the native version:

 - enforces that FREQ appears first
 - allows (but ignores) X-* parts
 - improved validation on various values
 - error messages are more specific
 - enforces that only one of UNTIL and COUNT may be present [disabled]
 - allows lower-case property and enumeration values [disabled]

As part of the transition process, both versions of the parser are
called on every request, and the results are compared.  If the results
are different a warning message is logged.

An unnecessary constructor was removed.

This also this moves some EventRecurrence tests out of CalendarProvider,
into coretests, and adds a simple parse test with the examples from
the RFC.

Bug 4575374

Change-Id: If737ed1272fda65c93363d87b2da12b85e644f5b

3 files changed, 1359 insertions, 46 deletions

diff --git a/core/java/android/pim/EventRecurrence.java b/core/java/android/pim/EventRecurrence.java
index 56c4f7a..cde7dac 100644
--- a/core/java/android/pim/EventRecurrence.java
+++ b/core/java/android/pim/EventRecurrence.java
@@ -18,36 +18,18 @@ package android.pim;
 
 import android.text.TextUtils;
 import android.text.format.Time;
+import android.util.Log;
+import android.util.TimeFormatException;
 
 import java.util.Calendar;
+import java.util.HashMap;
 
-public class EventRecurrence
-{
-    /**
-     * Thrown when a recurrence string provided can not be parsed according
-     * to RFC2445.
-     */
-    public static class InvalidFormatException extends RuntimeException
-    {
-        InvalidFormatException(String s) {
-            super(s);
-        }
-    }
-
-    public EventRecurrence()
-    {
-        wkst = MO;
-    }
-    
-    /**
-     * Parse an iCalendar/RFC2445 recur type according to Section 4.3.10.
-     */
-    public native void parse(String recur);
+/**
+ * Event recurrence utility functions.
+ */
+public class EventRecurrence {
+    private static String TAG = "EventRecur";
 
-    public void setStartDate(Time date) {
-        startDate = date;
-    }
-    
     public static final int SECONDLY = 1;
     public static final int MINUTELY = 2;
     public static final int HOURLY = 3;
@@ -64,13 +46,15 @@ public class EventRecurrence
     public static final int FR = 0x00200000;
     public static final int SA = 0x00400000;
 
-    public Time      startDate;
-    public int       freq;
+    public Time      startDate;     // set by setStartDate(), not parse()
+
+    public int       freq;          // SECONDLY, MINUTELY, etc.
     public String    until;
     public int       count;
     public int       interval;
-    public int       wkst;
+    public int       wkst;          // SU, MO, TU, etc.
 
+    /* lists with zero entries may be null references */
     public int[]     bysecond;
     public int       bysecondCount;
     public int[]     byminute;
@@ -79,7 +63,7 @@ public class EventRecurrence
     public int       byhourCount;
     public int[]     byday;
     public int[]     bydayNum;
-    public int       bydayCount;   
+    public int       bydayCount;
     public int[]     bymonthday;
     public int       bymonthdayCount;
     public int[]     byyearday;
@@ -91,6 +75,134 @@ public class EventRecurrence
     public int[]     bysetpos;
     public int       bysetposCount;
 
+    /** maps a part string to a parser object */
+    private static HashMap<String,PartParser> sParsePartMap;
+    static {
+        sParsePartMap = new HashMap<String,PartParser>();
+        sParsePartMap.put("FREQ", new ParseFreq());
+        sParsePartMap.put("UNTIL", new ParseUntil());
+        sParsePartMap.put("COUNT", new ParseCount());
+        sParsePartMap.put("INTERVAL", new ParseInterval());
+        sParsePartMap.put("BYSECOND", new ParseBySecond());
+        sParsePartMap.put("BYMINUTE", new ParseByMinute());
+        sParsePartMap.put("BYHOUR", new ParseByHour());
+        sParsePartMap.put("BYDAY", new ParseByDay());
+        sParsePartMap.put("BYMONTHDAY", new ParseByMonthDay());
+        sParsePartMap.put("BYYEARDAY", new ParseByYearDay());
+        sParsePartMap.put("BYWEEKNO", new ParseByWeekNo());
+        sParsePartMap.put("BYMONTH", new ParseByMonth());
+        sParsePartMap.put("BYSETPOS", new ParseBySetPos());
+        sParsePartMap.put("WKST", new ParseWkst());
+    }
+
+    /* values for bit vector that keeps track of what we have already seen */
+    private static final int PARSED_FREQ = 1 << 0;
+    private static final int PARSED_UNTIL = 1 << 1;
+    private static final int PARSED_COUNT = 1 << 2;
+    private static final int PARSED_INTERVAL = 1 << 3;
+    private static final int PARSED_BYSECOND = 1 << 4;
+    private static final int PARSED_BYMINUTE = 1 << 5;
+    private static final int PARSED_BYHOUR = 1 << 6;
+    private static final int PARSED_BYDAY = 1 << 7;
+    private static final int PARSED_BYMONTHDAY = 1 << 8;
+    private static final int PARSED_BYYEARDAY = 1 << 9;
+    private static final int PARSED_BYWEEKNO = 1 << 10;
+    private static final int PARSED_BYMONTH = 1 << 11;
+    private static final int PARSED_BYSETPOS = 1 << 12;
+    private static final int PARSED_WKST = 1 << 13;
+
+    /** maps a FREQ value to an integer constant */
+    private static final HashMap<String,Integer> sParseFreqMap = new HashMap<String,Integer>();
+    static {
+        sParseFreqMap.put("SECONDLY", SECONDLY);
+        sParseFreqMap.put("MINUTELY", MINUTELY);
+        sParseFreqMap.put("HOURLY", HOURLY);
+        sParseFreqMap.put("DAILY", DAILY);
+        sParseFreqMap.put("WEEKLY", WEEKLY);
+        sParseFreqMap.put("MONTHLY", MONTHLY);
+        sParseFreqMap.put("YEARLY", YEARLY);
+    }
+
+    /** maps a two-character weekday string to an integer constant */
+    private static final HashMap<String,Integer> sParseWeekdayMap = new HashMap<String,Integer>();
+    static {
+        sParseWeekdayMap.put("SU", SU);
+        sParseWeekdayMap.put("MO", MO);
+        sParseWeekdayMap.put("TU", TU);
+        sParseWeekdayMap.put("WE", WE);
+        sParseWeekdayMap.put("TH", TH);
+        sParseWeekdayMap.put("FR", FR);
+        sParseWeekdayMap.put("SA", SA);
+    }
+
+    /** If set, allow lower-case recurrence rule strings.  Minor performance impact. */
+    private static final boolean ALLOW_LOWER_CASE = false;
+
+    /** If set, validate the value of UNTIL parts.  Minor performance impact. */
+    private static final boolean VALIDATE_UNTIL = false;
+
+    /** If set, require that only one of {UNTIL,COUNT} is present.  Breaks compat w/ old parser. */
+    private static final boolean ONLY_ONE_UNTIL_COUNT = false;
+
+
+    /**
+     * Thrown when a recurrence string provided can not be parsed according
+     * to RFC2445.
+     */
+    public static class InvalidFormatException extends RuntimeException {
+        InvalidFormatException(String s) {
+            super(s);
+        }
+    }
+
+    /**
+     * Parse an iCalendar/RFC2445 recur type according to Section 4.3.10.  The string is
+     * parsed twice, by the old and new parsers, and the results are compared.
+     * <p>
+     * TODO: this will go away, and what is now parse2() will simply become parse().
+     */
+    public void parse(String recur) {
+        InvalidFormatException newExcep = null;
+        try {
+            parse2(recur);
+        } catch (InvalidFormatException ife) {
+            newExcep = ife;
+        }
+
+        boolean oldThrew = false;
+        try {
+            EventRecurrence check = new EventRecurrence();
+            check.parseNative(recur);
+            if (newExcep == null) {
+                // Neither threw, check to see if results match.
+                if (!equals(check)) {
+                    throw new InvalidFormatException("Recurrence rule parse does not match [" +
+                            recur + "]");
+                }
+            }
+        } catch (InvalidFormatException ife) {
+            oldThrew = true;
+            if (newExcep == null) {
+                // Old threw, but new didn't.  Log a warning, but don't throw.
+                Log.d(TAG, "NOTE: old parser rejected [" + recur + "]: " + ife.getMessage());
+            }
+        }
+
+        if (newExcep != null) {
+            if (!oldThrew) {
+                // New threw, but old didn't.  Log a warning and throw the exception.
+                Log.d(TAG, "NOTE: new parser rejected [" + recur + "]: " + newExcep.getMessage());
+            }
+            throw newExcep;
+        }
+    }
+
+    native void parseNative(String recur);
+
+    public void setStartDate(Time date) {
+        startDate = date;
+    }
+
     /**
      * Converts one of the Calendar.SUNDAY constants to the SU, MO, etc.
      * constants.  btw, I think we should switch to those here too, to
@@ -118,7 +230,7 @@ public class EventRecurrence
                 throw new RuntimeException("bad day of week: " + day);
         }
     }
-    
+
     public static int timeDay2Day(int day)
     {
         switch (day)
@@ -191,16 +303,16 @@ public class EventRecurrence
                 throw new RuntimeException("bad day of week: " + day);
         }
     }
-    
+
     /**
      * Converts one of the internal day constants (SU, MO, etc.) to the
      * two-letter string representing that constant.
-     * 
-     * @throws IllegalArgumentException Thrown if the day argument is not one of
-     * the defined day constants.
-     * 
+     *
      * @param day one the internal constants SU, MO, etc.
      * @return the two-letter string for the day ("SU", "MO", etc.)
+     *
+     * @throws IllegalArgumentException Thrown if the day argument is not one of
+     * the defined day constants.
      */
     private static String day2String(int day) {
         switch (day) {
@@ -283,7 +395,7 @@ public class EventRecurrence
             s.append(";UNTIL=");
             s.append(until);
         }
-        
+
         if (this.count != 0) {
             s.append(";COUNT=");
             s.append(this.count);
@@ -323,36 +435,484 @@ public class EventRecurrence
 
         return s.toString();
     }
-    
+
     public boolean repeatsOnEveryWeekDay() {
         if (this.freq != WEEKLY) {
-            return false; 
+            return false;
         }
-        
+
         int count = this.bydayCount;
         if (count != 5) {
             return false;
         }
-        
+
         for (int i = 0 ; i < count ; i++) {
             int day = byday[i];
             if (day == SU || day == SA) {
                 return false;
             }
         }
-        
+
         return true;
     }
-    
+
     public boolean repeatsMonthlyOnDayCount() {
         if (this.freq != MONTHLY) {
             return false;
         }
-        
+
         if (bydayCount != 1 || bymonthdayCount != 0) {
             return false;
         }
-        
+
+        return true;
+    }
+
+    /**
+     * Determines whether two integer arrays contain identical elements.
+     * <p>
+     * The native implementation over-allocated the arrays (and may have stuff left over from
+     * a previous run), so we can't just check the arrays -- the separately-maintained count
+     * field also matters.  We assume that a null array will have a count of zero, and that the
+     * array can hold as many elements as the associated count indicates.
+     * <p>
+     * TODO: replace this with Arrays.equals() when the old parser goes away.
+     */
+    private static boolean arraysEqual(int[] array1, int count1, int[] array2, int count2) {
+        if (count1 != count2) {
+            return false;
+        }
+
+        for (int i = 0; i < count1; i++) {
+            if (array1[i] != array2[i])
+                return false;
+        }
+
         return true;
     }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof EventRecurrence)) {
+            return false;
+        }
+
+        EventRecurrence er = (EventRecurrence) obj;
+        return  (startDate == null ?
+                        er.startDate == null : Time.compare(startDate, er.startDate) == 0) &&
+                freq == er.freq &&
+                (until == null ? er.until == null : until.equals(er.until)) &&
+                count == er.count &&
+                interval == er.interval &&
+                wkst == er.wkst &&
+                arraysEqual(bysecond, bysecondCount, er.bysecond, er.bysecondCount) &&
+                arraysEqual(byminute, byminuteCount, er.byminute, er.byminuteCount) &&
+                arraysEqual(byhour, byhourCount, er.byhour, er.byhourCount) &&
+                arraysEqual(byday, bydayCount, er.byday, er.bydayCount) &&
+                arraysEqual(bydayNum, bydayCount, er.bydayNum, er.bydayCount) &&
+                arraysEqual(bymonthday, bymonthdayCount, er.bymonthday, er.bymonthdayCount) &&
+                arraysEqual(byyearday, byyeardayCount, er.byyearday, er.byyeardayCount) &&
+                arraysEqual(byweekno, byweeknoCount, er.byweekno, er.byweeknoCount) &&
+                arraysEqual(bymonth, bymonthCount, er.bymonth, er.bymonthCount) &&
+                arraysEqual(bysetpos, bysetposCount, er.bysetpos, er.bysetposCount);
+    }
+
+    @Override public int hashCode() {
+        // We overrode equals, so we must override hashCode().  Nobody seems to need this though.
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Resets parser-modified fields to their initial state.  Does not alter startDate.
+     * <p>
+     * The original parser always set all of the "count" fields, "wkst", and "until",
+     * essentially allowing the same object to be used multiple times by calling parse().
+     * It's unclear whether this behavior was intentional.  For now, be paranoid and
+     * preserve the existing behavior by resetting the fields.
+     * <p>
+     * We don't need to touch the integer arrays; they will either be ignored or
+     * overwritten.  The "startDate" field is not set by the parser, so we ignore it here.
+     */
+    private void resetFields() {
+        until = null;
+        freq = count = interval = bysecondCount = byminuteCount = byhourCount =
+            bydayCount = bymonthdayCount = byyeardayCount = byweeknoCount = bymonthCount =
+            bysetposCount = 0;
+    }
+
+    /**
+     * Parses an rfc2445 recurrence rule string into its component pieces.  Attempting to parse
+     * malformed input will result in an EventRecurrence.InvalidFormatException.
+     *
+     * @param recur The recurrence rule to parse (in un-folded form).
+     */
+    void parse2(String recur) {
+        /*
+         * From RFC 2445 section 4.3.10:
+         *
+         * recur = "FREQ"=freq *(
+         *       ; either UNTIL or COUNT may appear in a 'recur',
+         *       ; but UNTIL and COUNT MUST NOT occur in the same 'recur'
+         *
+         *       ( ";" "UNTIL" "=" enddate ) /
+         *       ( ";" "COUNT" "=" 1*DIGIT ) /
+         *
+         *       ; the rest of these keywords are optional,
+         *       ; but MUST NOT occur more than once
+         *
+         *       ( ";" "INTERVAL" "=" 1*DIGIT )          /
+         *       ( ";" "BYSECOND" "=" byseclist )        /
+         *       ( ";" "BYMINUTE" "=" byminlist )        /
+         *       ( ";" "BYHOUR" "=" byhrlist )           /
+         *       ( ";" "BYDAY" "=" bywdaylist )          /
+         *       ( ";" "BYMONTHDAY" "=" bymodaylist )    /
+         *       ( ";" "BYYEARDAY" "=" byyrdaylist )     /
+         *       ( ";" "BYWEEKNO" "=" bywknolist )       /
+         *       ( ";" "BYMONTH" "=" bymolist )          /
+         *       ( ";" "BYSETPOS" "=" bysplist )         /
+         *       ( ";" "WKST" "=" weekday )              /
+         *       ( ";" x-name "=" text )
+         *       )
+         *
+         * Examples:
+         *   FREQ=MONTHLY;INTERVAL=2;COUNT=10;BYDAY=1SU,-1SU
+         *   FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8
+         *
+         * Strategy:
+         * (1) Split the string at ';' boundaries to get an array of rule "parts".
+         * (2) For each part, find substrings for left/right sides of '=' (name/value).
+         * (3) Call a <name>-specific parsing function to parse the <value> into an
+         *     output field.
+         *
+         * By keeping track of which names we've seen in a bit vector, we can verify the
+         * constraints indicated above (FREQ appears first, none of them appear more than once --
+         * though x-[name] would require special treatment), and we have either UNTIL or COUNT
+         * but not both.
+         *
+         * In general, RFC 2445 property names (e.g. "FREQ") and enumerations ("TU") must
+         * be handled in a case-insensitive fashion, but case may be significant for other
+         * properties.  We don't have any case-sensitive values in RRULE, except possibly
+         * for the custom "X-" properties, but we ignore those anyway.  Thus, we can trivially
+         * convert the entire string to upper case and then use simple comparisons.
+         *
+         * Differences from previous version:
+         * - allows lower-case property and enumeration values [optional]
+         * - enforces that FREQ appears first
+         * - enforces that only one of UNTIL and COUNT may be specified
+         * - allows (but ignores) X-* parts
+         * - improved validation on various values (e.g. UNTIL timestamps)
+         * - error messages are more specific
+         */
+
+        /* TODO: replace with "if (freq != 0) throw" if nothing requires this */
+        resetFields();
+
+        int parseFlags = 0;
+        String[] parts;
+        if (ALLOW_LOWER_CASE) {
+            parts = recur.toUpperCase().split(";");
+        } else {
+            parts = recur.split(";");
+        }
+        for (String part : parts) {
+            int equalIndex = part.indexOf('=');
+            if (equalIndex <= 0) {
+                /* no '=' or no LHS */
+                throw new InvalidFormatException("Missing LHS in " + part);
+            }
+
+            String lhs = part.substring(0, equalIndex);
+            String rhs = part.substring(equalIndex + 1);
+            if (rhs.length() == 0) {
+                throw new InvalidFormatException("Missing RHS in " + part);
+            }
+
+            /*
+             * In lieu of a "switch" statement that allows string arguments, we use a
+             * map from strings to parsing functions.
+             */
+            PartParser parser = sParsePartMap.get(lhs);
+            if (parser == null) {
+                if (lhs.startsWith("X-")) {
+                    //Log.d(TAG, "Ignoring custom part " + lhs);
+                    continue;
+                }
+                throw new InvalidFormatException("Couldn't find parser for " + lhs);
+            } else {
+                int flag = parser.parsePart(rhs, this);
+                if ((parseFlags & flag) != 0) {
+                    throw new InvalidFormatException("Part " + lhs + " was specified twice");
+                }
+                if (parseFlags == 0 && flag != PARSED_FREQ) {
+                    throw new InvalidFormatException("FREQ must be specified first");
+                }
+                parseFlags |= flag;
+            }
+        }
+
+        // If not specified, week starts on Monday.
+        if ((parseFlags & PARSED_WKST) == 0) {
+            wkst = MO;
+        }
+
+        // FREQ is mandatory.
+        if ((parseFlags & PARSED_FREQ) == 0) {
+            throw new InvalidFormatException("Must specify a FREQ value");
+        }
+
+        // Can't have both UNTIL and COUNT.
+        if ((parseFlags & (PARSED_UNTIL | PARSED_COUNT)) == (PARSED_UNTIL | PARSED_COUNT)) {
+            if (ONLY_ONE_UNTIL_COUNT) {
+                throw new InvalidFormatException("Must not specify both UNTIL and COUNT: " + recur);
+            } else {
+                Log.w(TAG, "Warning: rrule has both UNTIL and COUNT: " + recur);
+            }
+        }
+    }
+
+    /**
+     * Base class for the RRULE part parsers.
+     */
+    abstract static class PartParser {
+        /**
+         * Parses a single part.
+         *
+         * @param value The right-hand-side of the part.
+         * @param er The EventRecurrence into which the result is stored.
+         * @return A bit value indicating which part was parsed.
+         */
+        public abstract int parsePart(String value, EventRecurrence er);
+
+        /**
+         * Parses an integer, with range-checking.
+         *
+         * @param str The string to parse.
+         * @param minVal Minimum allowed value.
+         * @param maxVal Maximum allowed value.
+         * @param allowZero Is 0 allowed?
+         * @return The parsed value.
+         */
+        public static int parseIntRange(String str, int minVal, int maxVal, boolean allowZero) {
+            try {
+                if (str.charAt(0) == '+') {
+                    // Integer.parseInt does not allow a leading '+', so skip it manually.
+                    str = str.substring(1);
+                }
+                int val = Integer.parseInt(str);
+                if (val < minVal || val > maxVal || (val == 0 && !allowZero)) {
+                    throw new InvalidFormatException("Integer value out of range: " + str);
+                }
+                return val;
+            } catch (NumberFormatException nfe) {
+                throw new InvalidFormatException("Invalid integer value: " + str);
+            }
+        }
+
+        /**
+         * Parses a comma-separated list of integers, with range-checking.
+         *
+         * @param listStr The string to parse.
+         * @param minVal Minimum allowed value.
+         * @param maxVal Maximum allowed value.
+         * @param allowZero Is 0 allowed?
+         * @return A new array with values, sized to hold the exact number of elements.
+         */
+        public static int[] parseNumberList(String listStr, int minVal, int maxVal,
+                boolean allowZero) {
+            int[] values;
+
+            if (listStr.indexOf(",") < 0) {
+                // Common case: only one entry, skip split() overhead.
+                values = new int[1];
+                values[0] = parseIntRange(listStr, minVal, maxVal, allowZero);
+            } else {
+                String[] valueStrs = listStr.split(",");
+                int len = valueStrs.length;
+                values = new int[len];
+                for (int i = 0; i < len; i++) {
+                    values[i] = parseIntRange(valueStrs[i], minVal, maxVal, allowZero);
+                }
+            }
+            return values;
+        }
+   }
+
+    /** parses FREQ={SECONDLY,MINUTELY,...} */
+    private static class ParseFreq extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            Integer freq = sParseFreqMap.get(value);
+            if (freq == null) {
+                throw new InvalidFormatException("Invalid FREQ value: " + value);
+            }
+            er.freq = freq;
+            return PARSED_FREQ;
+        }
+    }
+    /** parses UNTIL=enddate, e.g. "19970829T021400" */
+    private static class ParseUntil extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            if (VALIDATE_UNTIL) {
+                try {
+                    // Parse the time to validate it.  The result isn't retained.
+                    Time until = new Time();
+                    until.parse(value);
+                } catch (TimeFormatException tfe) {
+                    throw new InvalidFormatException("Invalid UNTIL value: " + value);
+                }
+            }
+            er.until = value;
+            return PARSED_UNTIL;
+        }
+    }
+    /** parses COUNT=[non-negative-integer] */
+    private static class ParseCount extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            er.count = parseIntRange(value, 0, Integer.MAX_VALUE, true);
+            return PARSED_COUNT;
+        }
+    }
+    /** parses INTERVAL=[non-negative-integer] */
+    private static class ParseInterval extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            er.interval = parseIntRange(value, 1, Integer.MAX_VALUE, false);
+            return PARSED_INTERVAL;
+        }
+    }
+    /** parses BYSECOND=byseclist */
+    private static class ParseBySecond extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] bysecond = parseNumberList(value, 0, 59, true);
+            er.bysecond = bysecond;
+            er.bysecondCount = bysecond.length;
+            return PARSED_BYSECOND;
+        }
+    }
+    /** parses BYMINUTE=byminlist */
+    private static class ParseByMinute extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] byminute = parseNumberList(value, 0, 59, true);
+            er.byminute = byminute;
+            er.byminuteCount = byminute.length;
+            return PARSED_BYMINUTE;
+        }
+    }
+    /** parses BYHOUR=byhrlist */
+    private static class ParseByHour extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] byhour = parseNumberList(value, 0, 23, true);
+            er.byhour = byhour;
+            er.byhourCount = byhour.length;
+            return PARSED_BYHOUR;
+        }
+    }
+    /** parses BYDAY=bywdaylist, e.g. "1SU,-1SU" */
+    private static class ParseByDay extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] byday;
+            int[] bydayNum;
+            int bydayCount;
+
+            if (value.indexOf(",") < 0) {
+                /* only one entry, skip split() overhead */
+                bydayCount = 1;
+                byday = new int[1];
+                bydayNum = new int[1];
+                parseWday(value, byday, bydayNum, 0);
+            } else {
+                String[] wdays = value.split(",");
+                int len = wdays.length;
+                bydayCount = len;
+                byday = new int[len];
+                bydayNum = new int[len];
+                for (int i = 0; i < len; i++) {
+                    parseWday(wdays[i], byday, bydayNum, i);
+                }
+            }
+            er.byday = byday;
+            er.bydayNum = bydayNum;
+            er.bydayCount = bydayCount;
+            return PARSED_BYDAY;
+        }
+
+        /** parses [int]weekday, putting the pieces into parallel array entries */
+        private static void parseWday(String str, int[] byday, int[] bydayNum, int index) {
+            int wdayStrStart = str.length() - 2;
+            String wdayStr;
+
+            if (wdayStrStart > 0) {
+                /* number is included; parse it out and advance to weekday */
+                String numPart = str.substring(0, wdayStrStart);
+                int num = parseIntRange(numPart, -53, 53, false);
+                bydayNum[index] = num;
+                wdayStr = str.substring(wdayStrStart);
+            } else {
+                /* just the weekday string */
+                wdayStr = str;
+            }
+            Integer wday = sParseWeekdayMap.get(wdayStr);
+            if (wday == null) {
+                throw new InvalidFormatException("Invalid BYDAY value: " + str);
+            }
+            byday[index] = wday;
+        }
+    }
+    /** parses BYMONTHDAY=bymodaylist */
+    private static class ParseByMonthDay extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] bymonthday = parseNumberList(value, -31, 31, false);
+            er.bymonthday = bymonthday;
+            er.bymonthdayCount = bymonthday.length;
+            return PARSED_BYMONTHDAY;
+        }
+    }
+    /** parses BYYEARDAY=byyrdaylist */
+    private static class ParseByYearDay extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] byyearday = parseNumberList(value, -366, 366, false);
+            er.byyearday = byyearday;
+            er.byyeardayCount = byyearday.length;
+            return PARSED_BYYEARDAY;
+        }
+    }
+    /** parses BYWEEKNO=bywknolist */
+    private static class ParseByWeekNo extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] byweekno = parseNumberList(value, -53, 53, false);
+            er.byweekno = byweekno;
+            er.byweeknoCount = byweekno.length;
+            return PARSED_BYWEEKNO;
+        }
+    }
+    /** parses BYMONTH=bymolist */
+    private static class ParseByMonth extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] bymonth = parseNumberList(value, 1, 12, false);
+            er.bymonth = bymonth;
+            er.bymonthCount = bymonth.length;
+            return PARSED_BYMONTH;
+        }
+    }
+    /** parses BYSETPOS=bysplist */
+    private static class ParseBySetPos extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            int[] bysetpos = parseNumberList(value, Integer.MIN_VALUE, Integer.MAX_VALUE, true);
+            er.bysetpos = bysetpos;
+            er.bysetposCount = bysetpos.length;
+            return PARSED_BYSETPOS;
+        }
+    }
+    /** parses WKST={SU,MO,...} */
+    private static class ParseWkst extends PartParser {
+        @Override public int parsePart(String value, EventRecurrence er) {
+            Integer wkst = sParseWeekdayMap.get(value);
+            if (wkst == null) {
+                throw new InvalidFormatException("Invalid WKST value: " + value);
+            }
+            er.wkst = wkst;
+            return PARSED_WKST;
+        }
+    }
 }
diff --git a/core/jni/android_pim_EventRecurrence.cpp b/core/jni/android_pim_EventRecurrence.cpp
index 44e898d..3e11569 100644
--- a/core/jni/android_pim_EventRecurrence.cpp
+++ b/core/jni/android_pim_EventRecurrence.cpp
@@ -147,7 +147,7 @@ EventRecurrence_parse(JNIEnv* env, jobject This, jstring jstr)
  */

 static JNINativeMethod METHODS[] = {

     /* name, signature, funcPtr */

-    { "parse", "(Ljava/lang/String;)V", (void*)EventRecurrence_parse }

+    { "parseNative", "(Ljava/lang/String;)V", (void*)EventRecurrence_parse }

 };

 

 static const char*const CLASS_NAME = "android/pim/EventRecurrence";

diff --git a/core/tests/coretests/src/android/pim/EventRecurrenceTest.java b/core/tests/coretests/src/android/pim/EventRecurrenceTest.java
new file mode 100644
index 0000000..05000f1
--- /dev/null
+++ b/core/tests/coretests/src/android/pim/EventRecurrenceTest.java
@@ -0,0 +1,753 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.pim;
+
+import android.pim.EventRecurrence.InvalidFormatException;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.Suppress;
+
+import junit.framework.TestCase;
+
+import java.util.Arrays;
+
+/**
+ * Test android.pim.EventRecurrence.
+ *
+ * adb shell am instrument -w -e class android.pim.EventRecurrenceTest \
+ *   com.android.frameworks.coretests/android.test.InstrumentationTestRunner
+ */
+public class EventRecurrenceTest extends TestCase {
+
+    @SmallTest
+    public void test0() throws Exception {
+        verifyRecurType("FREQ=SECONDLY",
+                /* int freq */         EventRecurrence.SECONDLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test1() throws Exception {
+        verifyRecurType("FREQ=MINUTELY",
+                /* int freq */         EventRecurrence.MINUTELY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test2() throws Exception {
+        verifyRecurType("FREQ=HOURLY",
+                /* int freq */         EventRecurrence.HOURLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test3() throws Exception {
+        verifyRecurType("FREQ=DAILY",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test4() throws Exception {
+        verifyRecurType("FREQ=WEEKLY",
+                /* int freq */         EventRecurrence.WEEKLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test5() throws Exception {
+        verifyRecurType("FREQ=MONTHLY",
+                /* int freq */         EventRecurrence.MONTHLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test6() throws Exception {
+        verifyRecurType("FREQ=YEARLY",
+                /* int freq */         EventRecurrence.YEARLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test7() throws Exception {
+        // with an until
+        verifyRecurType("FREQ=DAILY;UNTIL=112233T223344Z",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     "112233T223344Z",
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test8() throws Exception {
+        // with a count
+        verifyRecurType("FREQ=DAILY;COUNT=334",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        334,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test9() throws Exception {
+        // with a count
+        verifyRecurType("FREQ=DAILY;INTERVAL=5000",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     5000,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @SmallTest
+    public void test10() throws Exception {
+        // verifyRecurType all of the BY* ones with one element
+        verifyRecurType("FREQ=DAILY"
+                + ";BYSECOND=0"
+                + ";BYMINUTE=1"
+                + ";BYHOUR=2"
+                + ";BYMONTHDAY=30"
+                + ";BYYEARDAY=300"
+                + ";BYWEEKNO=53"
+                + ";BYMONTH=12"
+                + ";BYSETPOS=-15"
+                + ";WKST=SU",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   new int[]{0},
+                /* int[] byminute */   new int[]{1},
+                /* int[] byhour */     new int[]{2},
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ new int[]{30},
+                /* int[] byyearday */  new int[]{300},
+                /* int[] byweekno */   new int[]{53},
+                /* int[] bymonth */    new int[]{12},
+                /* int[] bysetpos */   new int[]{-15},
+                /* int wkst */         EventRecurrence.SU
+        );
+    }
+
+    @SmallTest
+    public void test11() throws Exception {
+        // verifyRecurType all of the BY* ones with one element
+        verifyRecurType("FREQ=DAILY"
+                + ";BYSECOND=0,30,59"
+                + ";BYMINUTE=0,41,59"
+                + ";BYHOUR=0,4,23"
+                + ";BYMONTHDAY=-31,-1,1,31"
+                + ";BYYEARDAY=-366,-1,1,366"
+                + ";BYWEEKNO=-53,-1,1,53"
+                + ";BYMONTH=1,12"
+                + ";BYSETPOS=1,2,3,4,500,10000"
+                + ";WKST=SU",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   new int[]{0, 30, 59},
+                /* int[] byminute */   new int[]{0, 41, 59},
+                /* int[] byhour */     new int[]{0, 4, 23},
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ new int[]{-31, -1, 1, 31},
+                /* int[] byyearday */  new int[]{-366, -1, 1, 366},
+                /* int[] byweekno */   new int[]{-53, -1, 1, 53},
+                /* int[] bymonth */    new int[]{1, 12},
+                /* int[] bysetpos */   new int[]{1, 2, 3, 4, 500, 10000},
+                /* int wkst */         EventRecurrence.SU
+        );
+    }
+
+    private static class Check {
+        Check(String k, int... v) {
+            key = k;
+            values = v;
+        }
+
+        String key;
+        int[] values;
+    }
+
+    // this is a negative verifyRecurType case to verifyRecurType the range of the numbers accepted
+    @SmallTest
+    public void test12() throws Exception {
+        Check[] checks = new Check[]{
+                new Check("BYSECOND", -100, -1, 60, 100),
+                new Check("BYMINUTE", -100, -1, 60, 100),
+                new Check("BYHOUR", -100, -1, 24, 100),
+                new Check("BYMONTHDAY", -100, -32, 0, 32, 100),
+                new Check("BYYEARDAY", -400, -367, 0, 367, 400),
+                new Check("BYWEEKNO", -100, -54, 0, 54, 100),
+                new Check("BYMONTH", -100, -5, 0, 13, 100)
+        };
+
+        for (Check ck : checks) {
+            for (int n : ck.values) {
+                String recur = "FREQ=DAILY;" + ck.key + "=" + n;
+                try {
+                    EventRecurrence er = new EventRecurrence();
+                    er.parse(recur);
+                    fail("Negative verifyRecurType failed. "
+                            + " parse failed to throw an exception for '"
+                            + recur + "'");
+                } catch (EventRecurrence.InvalidFormatException e) {
+                    // expected
+                }
+            }
+        }
+    }
+
+    // verifyRecurType BYDAY
+    @SmallTest
+    public void test13() throws Exception {
+        verifyRecurType("FREQ=DAILY;BYDAY=1SU,-2MO,+33TU,WE,TH,FR,SA",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.SU,
+                        EventRecurrence.MO,
+                        EventRecurrence.TU,
+                        EventRecurrence.WE,
+                        EventRecurrence.TH,
+                        EventRecurrence.FR,
+                        EventRecurrence.SA
+                },
+                /* int[] bydayNum */   new int[]{1, -2, 33, 0, 0, 0, 0},
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    @Suppress
+    // Repro bug #2331761 - this should fail because of the last comma into BYDAY
+    public void test14() throws Exception {
+        verifyRecurType("FREQ=WEEKLY;WKST=MO;UNTIL=20100129T130000Z;INTERVAL=1;BYDAY=MO,TU,WE,",
+                /* int freq */         EventRecurrence.WEEKLY,
+                /* String until */     "20100129T130000Z",
+                /* int count */        0,
+                /* int interval */     1,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.MO,
+                        EventRecurrence.TU,
+                        EventRecurrence.WE,
+                },
+                /* int[] bydayNum */   new int[]{0, 0, 0},
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // This test should pass
+    public void test15() throws Exception {
+        verifyRecurType("FREQ=WEEKLY;WKST=MO;UNTIL=20100129T130000Z;INTERVAL=1;"
+                + "BYDAY=MO,TU,WE,TH,FR,SA,SU",
+                /* int freq */         EventRecurrence.WEEKLY,
+                /* String until */     "20100129T130000Z",
+                /* int count */        0,
+                /* int interval */     1,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.MO,
+                        EventRecurrence.TU,
+                        EventRecurrence.WE,
+                        EventRecurrence.TH,
+                        EventRecurrence.FR,
+                        EventRecurrence.SA,
+                        EventRecurrence.SU
+                },
+                /* int[] bydayNum */   new int[]{0, 0, 0, 0, 0, 0, 0},
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // Sample coming from RFC2445
+    public void test16() throws Exception {
+        verifyRecurType("FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1",
+                /* int freq */         EventRecurrence.MONTHLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.MO,
+                        EventRecurrence.TU,
+                        EventRecurrence.WE,
+                        EventRecurrence.TH,
+                        EventRecurrence.FR
+                },
+                /* int[] bydayNum */   new int[] {0, 0, 0, 0, 0},
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   new int[] { -1 },
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // Sample coming from RFC2445
+    public void test17() throws Exception {
+        verifyRecurType("FREQ=DAILY;COUNT=10;INTERVAL=2",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        10,
+                /* int interval */     2,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // Sample coming from RFC2445
+    public void test18() throws Exception {
+        verifyRecurType("FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10",
+                /* int freq */         EventRecurrence.YEARLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.SU
+                },
+                /* int[] bydayNum */   new int[] { -1 },
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    new int[] { 10 },
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // Sample coming from bug #1640517
+    public void test19() throws Exception {
+        verifyRecurType("FREQ=YEARLY;BYMONTH=3;BYDAY=TH",
+                /* int freq */         EventRecurrence.YEARLY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      new int[] {
+                        EventRecurrence.TH
+                },
+                /* int[] bydayNum */   new int[] { 0 },
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    new int[] { 3 },
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    // for your copying pleasure
+    public void fakeTestXX() throws Exception {
+        verifyRecurType("FREQ=DAILY;",
+                /* int freq */         EventRecurrence.DAILY,
+                /* String until */     null,
+                /* int count */        0,
+                /* int interval */     0,
+                /* int[] bysecond */   null,
+                /* int[] byminute */   null,
+                /* int[] byhour */     null,
+                /* int[] byday */      null,
+                /* int[] bydayNum */   null,
+                /* int[] bymonthday */ null,
+                /* int[] byyearday */  null,
+                /* int[] byweekno */   null,
+                /* int[] bymonth */    null,
+                /* int[] bysetpos */   null,
+                /* int wkst */         EventRecurrence.MO
+        );
+    }
+
+    private static void cmp(int vlen, int[] v, int[] correct, String name) {
+        if ((correct == null && v != null)
+                || (correct != null && v == null)) {
+            throw new RuntimeException("One is null, one isn't for " + name
+                    + ": correct=" + Arrays.toString(correct)
+                    + " actual=" + Arrays.toString(v));
+        }
+        if ((correct == null && vlen != 0)
+                || (vlen != (correct == null ? 0 : correct.length))) {
+            throw new RuntimeException("Reported length mismatch for " + name
+                    + ": correct=" + ((correct == null) ? "null" : correct.length)
+                    + " actual=" + vlen);
+        }
+        if (correct == null) {
+            return;
+        }
+        if (v.length < correct.length) {
+            throw new RuntimeException("Array length mismatch for " + name
+                    + ": correct=" + Arrays.toString(correct)
+                    + " actual=" + Arrays.toString(v));
+        }
+        for (int i = 0; i < correct.length; i++) {
+            if (v[i] != correct[i]) {
+                throw new RuntimeException("Array value mismatch for " + name
+                        + ": correct=" + Arrays.toString(correct)
+                        + " actual=" + Arrays.toString(v));
+            }
+        }
+    }
+
+    private static boolean eq(String a, String b) {
+        if ((a == null && b != null) || (a != null && b == null)) {
+            return false;
+        } else {
+            return a == b || a.equals(b);
+        }
+    }
+
+    private static void verifyRecurType(String recur,
+            int freq, String until, int count, int interval,
+            int[] bysecond, int[] byminute, int[] byhour,
+            int[] byday, int[] bydayNum, int[] bymonthday,
+            int[] byyearday, int[] byweekno, int[] bymonth,
+            int[] bysetpos, int wkst) {
+        EventRecurrence eventRecurrence = new EventRecurrence();
+        eventRecurrence.parse(recur);
+        if (eventRecurrence.freq != freq
+                || !eq(eventRecurrence.until, until)
+                || eventRecurrence.count != count
+                || eventRecurrence.interval != interval
+                || eventRecurrence.wkst != wkst) {
+            System.out.println("Error... got:");
+            print(eventRecurrence);
+            System.out.println("expected:");
+            System.out.println("{");
+            System.out.println("    freq=" + freq);
+            System.out.println("    until=" + until);
+            System.out.println("    count=" + count);
+            System.out.println("    interval=" + interval);
+            System.out.println("    wkst=" + wkst);
+            System.out.println("    bysecond=" + Arrays.toString(bysecond));
+            System.out.println("    byminute=" + Arrays.toString(byminute));
+            System.out.println("    byhour=" + Arrays.toString(byhour));
+            System.out.println("    byday=" + Arrays.toString(byday));
+            System.out.println("    bydayNum=" + Arrays.toString(bydayNum));
+            System.out.println("    bymonthday=" + Arrays.toString(bymonthday));
+            System.out.println("    byyearday=" + Arrays.toString(byyearday));
+            System.out.println("    byweekno=" + Arrays.toString(byweekno));
+            System.out.println("    bymonth=" + Arrays.toString(bymonth));
+            System.out.println("    bysetpos=" + Arrays.toString(bysetpos));
+            System.out.println("}");
+            throw new RuntimeException("Mismatch in fields");
+        }
+        cmp(eventRecurrence.bysecondCount, eventRecurrence.bysecond, bysecond, "bysecond");
+        cmp(eventRecurrence.byminuteCount, eventRecurrence.byminute, byminute, "byminute");
+        cmp(eventRecurrence.byhourCount, eventRecurrence.byhour, byhour, "byhour");
+        cmp(eventRecurrence.bydayCount, eventRecurrence.byday, byday, "byday");
+        cmp(eventRecurrence.bydayCount, eventRecurrence.bydayNum, bydayNum, "bydayNum");
+        cmp(eventRecurrence.bymonthdayCount, eventRecurrence.bymonthday, bymonthday, "bymonthday");
+        cmp(eventRecurrence.byyeardayCount, eventRecurrence.byyearday, byyearday, "byyearday");
+        cmp(eventRecurrence.byweeknoCount, eventRecurrence.byweekno, byweekno, "byweekno");
+        cmp(eventRecurrence.bymonthCount, eventRecurrence.bymonth, bymonth, "bymonth");
+        cmp(eventRecurrence.bysetposCount, eventRecurrence.bysetpos, bysetpos, "bysetpos");
+    }
+
+    private static void print(EventRecurrence er) {
+        System.out.println("{");
+        System.out.println("    freq=" + er.freq);
+        System.out.println("    until=" + er.until);
+        System.out.println("    count=" + er.count);
+        System.out.println("    interval=" + er.interval);
+        System.out.println("    wkst=" + er.wkst);
+        System.out.println("    bysecond=" + Arrays.toString(er.bysecond));
+        System.out.println("    bysecondCount=" + er.bysecondCount);
+        System.out.println("    byminute=" + Arrays.toString(er.byminute));
+        System.out.println("    byminuteCount=" + er.byminuteCount);
+        System.out.println("    byhour=" + Arrays.toString(er.byhour));
+        System.out.println("    byhourCount=" + er.byhourCount);
+        System.out.println("    byday=" + Arrays.toString(er.byday));
+        System.out.println("    bydayNum=" + Arrays.toString(er.bydayNum));
+        System.out.println("    bydayCount=" + er.bydayCount);
+        System.out.println("    bymonthday=" + Arrays.toString(er.bymonthday));
+        System.out.println("    bymonthdayCount=" + er.bymonthdayCount);
+        System.out.println("    byyearday=" + Arrays.toString(er.byyearday));
+        System.out.println("    byyeardayCount=" + er.byyeardayCount);
+        System.out.println("    byweekno=" + Arrays.toString(er.byweekno));
+        System.out.println("    byweeknoCount=" + er.byweeknoCount);
+        System.out.println("    bymonth=" + Arrays.toString(er.bymonth));
+        System.out.println("    bymonthCount=" + er.bymonthCount);
+        System.out.println("    bysetpos=" + Arrays.toString(er.bysetpos));
+        System.out.println("    bysetposCount=" + er.bysetposCount);
+        System.out.println("}");
+    }
+
+
+    /** A list of valid rules.  The parser must accept these. */
+    private static final String[] GOOD_RRULES = {
+        /* extracted wholesale from from RFC 2445 section 4.8.5.4 */
+        "FREQ=DAILY;COUNT=10",
+        "FREQ=DAILY;UNTIL=19971224T000000Z",
+        "FREQ=DAILY;INTERVAL=2",
+        "FREQ=DAILY;INTERVAL=10;COUNT=5",
+        "FREQ=YEARLY;UNTIL=20000131T090000Z;BYMONTH=1;BYDAY=SU,MO,TU,WE,TH,FR,SA",
+        "FREQ=DAILY;UNTIL=20000131T090000Z;BYMONTH=1",
+        "FREQ=WEEKLY;COUNT=10",
+        "FREQ=WEEKLY;UNTIL=19971224T000000Z",
+        "FREQ=WEEKLY;INTERVAL=2;WKST=SU",
+        "FREQ=WEEKLY;UNTIL=19971007T000000Z;WKST=SU;BYDAY=TU,TH",
+        "FREQ=WEEKLY;COUNT=10;WKST=SU;BYDAY=TU,TH",
+        "FREQ=WEEKLY;INTERVAL=2;UNTIL=19971224T000000Z;WKST=SU;BYDAY=MO,WE,FR",
+        "FREQ=WEEKLY;INTERVAL=2;COUNT=8;WKST=SU;BYDAY=TU,TH",
+        "FREQ=MONTHLY;COUNT=10;BYDAY=1FR",
+        "FREQ=MONTHLY;UNTIL=19971224T000000Z;BYDAY=1FR",
+        "FREQ=MONTHLY;INTERVAL=2;COUNT=10;BYDAY=1SU,-1SU",
+        "FREQ=MONTHLY;COUNT=6;BYDAY=-2MO",
+        "FREQ=MONTHLY;BYMONTHDAY=-3",
+        "FREQ=MONTHLY;COUNT=10;BYMONTHDAY=2,15",
+        "FREQ=MONTHLY;COUNT=10;BYMONTHDAY=1,-1",
+        "FREQ=MONTHLY;INTERVAL=18;COUNT=10;BYMONTHDAY=10,11,12,13,14,15",
+        "FREQ=MONTHLY;INTERVAL=2;BYDAY=TU",
+        "FREQ=YEARLY;COUNT=10;BYMONTH=6,7",
+        "FREQ=YEARLY;INTERVAL=2;COUNT=10;BYMONTH=1,2,3",
+        "FREQ=YEARLY;INTERVAL=3;COUNT=10;BYYEARDAY=1,100,200",
+        "FREQ=YEARLY;BYDAY=20MO",
+        "FREQ=YEARLY;BYWEEKNO=20;BYDAY=MO",
+        "FREQ=YEARLY;BYMONTH=3;BYDAY=TH",
+        "FREQ=YEARLY;BYDAY=TH;BYMONTH=6,7,8",
+        "FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13",
+        "FREQ=MONTHLY;BYDAY=SA;BYMONTHDAY=7,8,9,10,11,12,13",
+        "FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8",
+        "FREQ=MONTHLY;COUNT=3;BYDAY=TU,WE,TH;BYSETPOS=3",
+        "FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-2",
+        "FREQ=HOURLY;INTERVAL=3;UNTIL=19970902T170000Z",
+        "FREQ=MINUTELY;INTERVAL=15;COUNT=6",
+        "FREQ=MINUTELY;INTERVAL=90;COUNT=4",
+        "FREQ=DAILY;BYHOUR=9,10,11,12,13,14,15,16;BYMINUTE=0,20,40",
+        "FREQ=MINUTELY;INTERVAL=20;BYHOUR=9,10,11,12,13,14,15,16",
+        "FREQ=WEEKLY;INTERVAL=2;COUNT=4;BYDAY=TU,SU;WKST=MO",
+        "FREQ=WEEKLY;INTERVAL=2;COUNT=4;BYDAY=TU,SU;WKST=SU",
+        /* a few more */
+        "FREQ=SECONDLY;BYSECOND=0,15,59",
+        "FREQ=MINUTELY;BYMINUTE=0,15,59",
+        "FREQ=HOURLY;BYHOUR=+0,+15,+23",
+        "FREQ=DAILY;X-WHATEVER=blah",                       // fails on old parser
+        //"freq=daily;wkst=su",                               // fails on old parser
+    };
+
+    /** The parser must reject these. */
+    private static final String[] BAD_RRULES = {
+        "INTERVAL=4;FREQ=YEARLY",                           // FREQ must come first
+        "FREQ=MONTHLY;FREQ=MONTHLY",                        // can't specify twice
+        "FREQ=MONTHLY;COUNT=1;COUNT=1",                     // can't specify twice
+        "FREQ=SECONDLY;BYSECOND=60",                        // range
+        "FREQ=MINUTELY;BYMINUTE=-1",                        // range
+        "FREQ=HOURLY;BYHOUR=24",                            // range
+        "FREQ=YEARLY;BYMONTHDAY=0",                         // zero not valid
+        //"FREQ=YEARLY;COUNT=1;UNTIL=12345",                  // can't have both COUNT and UNTIL
+        //"FREQ=DAILY;UNTIL=19970829T021400e",                // invalid date
+    };
+
+    /**
+     * Simple test of good/bad rules.
+     */
+    @SmallTest
+    public void testBasicParse() {
+        for (String rule : GOOD_RRULES) {
+            EventRecurrence recur = new EventRecurrence();
+            recur.parse(rule);
+        }
+
+        for (String rule : BAD_RRULES) {
+            EventRecurrence recur = new EventRecurrence();
+            boolean didThrow = false;
+
+            try {
+                recur.parse(rule);
+            } catch (InvalidFormatException ife) {
+                didThrow = true;
+            }
+
+            assertTrue("Expected throw on " + rule, didThrow);
+        }
+    }
+}