Index: test/icalendartest.rb
===================================================================
--- test/icalendartest.rb	(revision 179)
+++ test/icalendartest.rb	(working copy)
@@ -63,9 +63,7 @@
       DateTime.parse("US-Eastern:19971002T090000"), #Oct 02                                         
     ]
 
-    #we have to set the precision for use in EveryTE
-    start_date.date_precision = DPrecision::DAY    
-    te = REWeek.new(Sun,Sat) & EveryTE.new(start_date, 2)    
+    te = REWeek.new(Sun,Sat) & EveryTE.new(start_date, 2, DPrecision::DAY)    
     results = te.dates(DateRange.new(start_date, end_date))
     assert_equal(expected, results)    
     
@@ -90,9 +88,7 @@
       DateTime.parse("US-Eastern:19971012T090000"), #Oct 12
     ]
 
-    #we have to set the precision for use in EveryTE
-    start_date.date_precision = DPrecision::DAY    
-    te = REWeek.new(Sun,Sat) & EveryTE.new(start_date, 10)
+    te = REWeek.new(Sun,Sat) & EveryTE.new(start_date, 10, DPrecision::DAY)
     results = te.dates(DateRange.new(start_date, end_date), 5)
     assert_equal(expected, results)    
     
@@ -136,12 +132,13 @@
     assert_equal(expected, results)
   end
 
-=begin
   # "Weekly for 10 occurrences"
   def test_example_6
-    start_date = DateTime.parse("US-Eastern:19970902T090000")
-    rrule = RecurrenceRule.new("FREQ=WEEKLY;COUNT=10")
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = start_date + 365 #Sep 2, 1998    
     
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;COUNT=10")
+    
     expected = [
       DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
       DateTime.parse("US-Eastern:19970909T090000"), #Sep 9
@@ -154,16 +151,19 @@
       DateTime.parse("US-Eastern:19971028T090000"), #Oct 28
       DateTime.parse("US-Eastern:19971104T090000"), #Nov 4
     ]
-    results = te.dates(DateRange.new(start_date, END_DATE))
     
+    te = EveryTE.new(start_date, 7, DPrecision::DAY) 
+    results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end
-
+  
   # "Weekly until December 24th, 1997"
   def test_example_7
-    start_date = DateTime.parse("US-Eastern:19970902T090000")
-    rrule = RecurrenceRule.new("FREQ=WEEKLY;UNTIL=19971224T000000Z")
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = start_date + 365 #Sep 2, 1998  
     
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;UNTIL=19971224T000000Z")
+    
     expected = [
       DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
       DateTime.parse("US-Eastern:19970909T090000"), #Sep 9
@@ -183,20 +183,45 @@
       DateTime.parse("US-Eastern:19971216T090000"), #Dec 16
       DateTime.parse("US-Eastern:19971223T090000"), #Dec 23
     ]
-    results = te.dates(DateRange.new(start_date, END_DATE))
     
+    te = BeforeTE.new(DateTime.parse("19971224T000000"), true) & EveryTE.new(start_date, 7, DPrecision::DAY) 
+    results = te.dates(DateRange.new(start_date, end_date))
     assert_equal(expected, results)
   end
-  
+
   # "Every other week - forever"
   def test_example_8
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = DateTime.parse("US-Eastern:19980201T090000") # Feb 1st, 1998
+    
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;INTERVAL=2;WKST=SU")
+
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
+      DateTime.parse("US-Eastern:19970916T090000"), #Sep 16
+      DateTime.parse("US-Eastern:19970930T090000"), #Sep 30
+      DateTime.parse("US-Eastern:19971014T090000"), #Oct 14
+      DateTime.parse("US-Eastern:19971028T090000"), #Oct 28
+      DateTime.parse("US-Eastern:19971111T090000"), #Nov 11
+      DateTime.parse("US-Eastern:19971125T090000"), #Nov 25
+      DateTime.parse("US-Eastern:19971209T090000"), #Dec 9
+      DateTime.parse("US-Eastern:19971223T090000"), #Dec 23
+      DateTime.parse("US-Eastern:19980106T090000"), #Jan 6
+      DateTime.parse("US-Eastern:19980120T090000"), #Jan 20
+    ]    
+
+    te = EveryTE.new(start_date, 7*2, DPrecision::DAY) 
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
   end
-  
+
   # "Weekly on Tuesday and Thursday for 5 weeks (first example, using until)"
   def test_example_9_a
-    start_date = DateTime.parse("US-Eastern:19970902T090000")
-    rrule = RecurrenceRule.new("FREQ=WEEKLY;UNTIL=19971007T000000Z;WKST=SU;BYDAY=TU,TH")
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = DateTime.parse("US-Eastern:19980101T090000") # Jan 1st, 1998
     
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;UNTIL=19971007T000000Z;WKST=SU;BYDAY=TU,TH")
+    
     expected = [
       DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
       DateTime.parse("US-Eastern:19970904T090000"), #Sep 4
@@ -209,15 +234,18 @@
       DateTime.parse("US-Eastern:19970930T090000"), #Sep 30
       DateTime.parse("US-Eastern:19971002T090000"), #Oct 2
     ]
-    results = te.dates(DateRange.new(start_date, END_DATE))
     
+    te = BeforeTE.new(DateTime.parse("19971007T000000Z"), true) & (DIWeek.new(Tue) | DIWeek.new(Thu))
+    results = te.dates(DateRange.new(start_date, end_date))
     assert_equal(expected, results)
   end  
 
   # "Weekly on Tuesday and Thursday for 5 weeks (second example, using count)"
   def test_example_9_b
-    start_date = DateTime.parse("US-Eastern:19970902T090000")
-    rrule = RecurrenceRule.new("FREQ=WEEKLY;COUNT=10;WKST=SU;BYDAY=TU,TH")
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = DateTime.parse("US-Eastern:19980101T090000") # Jan 1st, 1998
+
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;COUNT=10;WKST=SU;BYDAY=TU,TH")
     
     expected = [
       DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
@@ -231,20 +259,78 @@
       DateTime.parse("US-Eastern:19970930T090000"), #Sep 30
       DateTime.parse("US-Eastern:19971002T090000"), #Oct 2
     ]
-    results = te.dates(DateRange.new(start_date, END_DATE))
     
+    te = DIWeek.new(Tue) | DIWeek.new(Thu)
+    results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end 
-
+  
   # "Every other week on Monday, Wednesday, and Friday until December 24, 1997
   # but starting on Tuesday, September 2, 1997"
   def test_example_10
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = DateTime.parse("US-Eastern:19980201T090000") # Feb 1st, 1998
+    
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;INTERVAL=2;UNTIL=19971224T000000Z;WKST=SU;BYDAY=MO,WE,FR")
+    
+    expected = [
+      #LJK: note that Sep 2nd is listed in the example, but it does not match the given RRULE.
+      # It definitely is not rendered by the TE below, so I'm just commenting it out for more research.
+      #DateTime.parse("US-Eastern:19970902T090000"), #Sep 2  
+      
+      DateTime.parse("US-Eastern:19970903T090000"), #Sep 3
+      DateTime.parse("US-Eastern:19970905T090000"), #Sep 5
+      DateTime.parse("US-Eastern:19970915T090000"), #Sep 15
+      DateTime.parse("US-Eastern:19970917T090000"), #Sep 17
+      DateTime.parse("US-Eastern:19970919T090000"), #Sep 19
+      DateTime.parse("US-Eastern:19970929T090000"), #Sep 29
+      DateTime.parse("US-Eastern:19971001T090000"), #Oct 1
+      DateTime.parse("US-Eastern:19971003T090000"), #Oct 3
+      DateTime.parse("US-Eastern:19971013T090000"), #Oct 13
+      DateTime.parse("US-Eastern:19971015T090000"), #Oct 15
+      DateTime.parse("US-Eastern:19971017T090000"), #Oct 17
+      DateTime.parse("US-Eastern:19971027T090000"), #Oct 27
+      DateTime.parse("US-Eastern:19971029T090000"), #Oct 29
+      DateTime.parse("US-Eastern:19971031T090000"), #Oct 31
+      DateTime.parse("US-Eastern:19971110T090000"), #Nov 10
+      DateTime.parse("US-Eastern:19971112T090000"), #Nov 12
+      DateTime.parse("US-Eastern:19971114T090000"), #Nov 14
+      DateTime.parse("US-Eastern:19971124T090000"), #Nov 24
+      DateTime.parse("US-Eastern:19971126T090000"), #Nov 26
+      DateTime.parse("US-Eastern:19971128T090000"), #Nov 28
+      DateTime.parse("US-Eastern:19971208T090000"), #Dec 8
+      DateTime.parse("US-Eastern:19971210T090000"), #Dec 10
+      DateTime.parse("US-Eastern:19971212T090000"), #Dec 12
+      DateTime.parse("US-Eastern:19971222T090000"), #Dec 22
+    ]    
+
+    te = BeforeTE.new(DateTime.parse("19971224T000000Z"), true) & (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & EveryTE.new(start_date, 2, DPrecision::WEEK) 
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
   end
   
   # "Every other week on Tuesday and Thursday, for 8 occurences"
   def test_example_11
+    start_date = DateTime.parse("US-Eastern:19970902T090000") # Sep 2nd, 1997
+    end_date   = DateTime.parse("US-Eastern:19980201T090000") # Feb 1st, 1998
+    
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;INTERVAL=2;COUNT=8;WKST=SU;BYDAY=TU,TH")
+    
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2
+      DateTime.parse("US-Eastern:19970904T090000"), #Sep 4
+      DateTime.parse("US-Eastern:19970916T090000"), #Sep 16
+      DateTime.parse("US-Eastern:19970918T090000"), #Sep 18
+      DateTime.parse("US-Eastern:19970930T090000"), #Sep 30
+      DateTime.parse("US-Eastern:19971002T090000"), #Oct 2
+      DateTime.parse("US-Eastern:19971014T090000"), #Oct 14
+      DateTime.parse("US-Eastern:19971016T090000"), #Oct 16
+    ]    
+
+    te = EveryTE.new(start_date, 2, DPrecision::WEEK) & (DIWeek.new(Tue) | DIWeek.new(Thu))
+    results = te.dates(DateRange.new(start_date, end_date), 8)
+    assert_equal(expected, results)        
   end
-=end 
 
   # "Monthly on the 1st Friday for ten occurences"
   def test_example_12
@@ -310,9 +396,7 @@
       DateTime.parse("US-Eastern:19980531T090000"), #May 31
     ]
     
-    #set the date precision for the EveryTe
-    start_date.date_precision = DPrecision::MONTH
-    te = EveryTE.new(start_date, 2) & (DIMonth.new(1,0) | DIMonth.new(-1,0)) #first and last Sundays
+    te = EveryTE.new(start_date, 2, DPrecision::MONTH) & (DIMonth.new(1,0) | DIMonth.new(-1,0)) #first and last Sundays
     results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end
@@ -435,9 +519,7 @@
       DateTime.parse("US-Eastern:19990313T090000"), #Mar 13, 1999            
     ]
   
-    #we have to set the precision for use in EveryTE
-    start_date.date_precision = DPrecision::MONTH    
-    te = EveryTE.new(start_date, 18) & REMonth.new(10,15)  #tenth through the fifteenth
+    te = EveryTE.new(start_date, 18, DPrecision::MONTH) & REMonth.new(10,15)  #tenth through the fifteenth
     results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end
@@ -458,21 +540,19 @@
       DateTime.parse("US-Eastern:19971104T090000"), #Nov 04, 1997
       DateTime.parse("US-Eastern:19971111T090000"), #Nov 11, 1997
       DateTime.parse("US-Eastern:19971118T090000"), #Nov 18, 1997
-      DateTime.parse("US-Eastern:19971125T090000"), #Nov 25, 1997            
+      DateTime.parse("US-Eastern:19971125T090000"), #Nov 25, 1997
       DateTime.parse("US-Eastern:19980106T090000"), #Jan 06, 1998
       DateTime.parse("US-Eastern:19980113T090000"), #Jan 13, 1998
       DateTime.parse("US-Eastern:19980120T090000"), #Jan 20, 1998
       DateTime.parse("US-Eastern:19980127T090000"), #Jan 27, 1998
-      DateTime.parse("US-Eastern:19980303T090000"), #Mar 03, 1998                                          
-      DateTime.parse("US-Eastern:19980310T090000"), #Mar 10, 1998                                          
-      DateTime.parse("US-Eastern:19980317T090000"), #Mar 17, 1998                                          
-      DateTime.parse("US-Eastern:19980324T090000"), #Mar 24, 1998                                          
-      DateTime.parse("US-Eastern:19980331T090000"), #Mar 31, 1998                                                                  
+      DateTime.parse("US-Eastern:19980303T090000"), #Mar 03, 1998
+      DateTime.parse("US-Eastern:19980310T090000"), #Mar 10, 1998
+      DateTime.parse("US-Eastern:19980317T090000"), #Mar 17, 1998
+      DateTime.parse("US-Eastern:19980324T090000"), #Mar 24, 1998
+      DateTime.parse("US-Eastern:19980331T090000"), #Mar 31, 1998
     ]
   
-    #we have to set the precision for use in EveryTE
-    start_date.date_precision = DPrecision::MONTH    
-    te = EveryTE.new(start_date, 2) & DIWeek.new(Tuesday)
+    te = EveryTE.new(start_date, 2, DPrecision::MONTH) & DIWeek.new(Tuesday)
     results = te.dates(DateRange.new(start_date, end_date))
     assert_equal(expected, results)
   end
@@ -501,13 +581,513 @@
       DateTime.parse("US-Eastern:20010710T090000"), #Jul 10, 2001
     ]
     
-    #we have to set the precision for use in EveryTE
-    start_date.date_precision = DPrecision::YEAR
     te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
     results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end
 
+  # "Every other year on January, February, and March for 10 occurrences"
+  def test_example_22
+    start_date = DateTime.parse("US-Eastern:19970310T090000") #Mar 10, 1997
+    end_date   = DateTime.parse("US-Eastern:20040401T090000") #Apr 1, 2004
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;INTERVAL=2;COUNT=10;BYMONTH=1,2,3")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970310T090000"), #Mar 10, 1997
+      DateTime.parse("US-Eastern:19990110T090000"), #Jan 10, 1999
+      DateTime.parse("US-Eastern:19990210T090000"), #Feb 10, 1999
+      DateTime.parse("US-Eastern:19990310T090000"), #Mar 10, 1999
+      DateTime.parse("US-Eastern:20010110T090000"), #Jan 10, 2001
+      DateTime.parse("US-Eastern:20010210T090000"), #Feb 10, 2001
+      DateTime.parse("US-Eastern:20010310T090000"), #Mar 10, 2001
+      DateTime.parse("US-Eastern:20030110T090000"), #Jan 10, 2003
+      DateTime.parse("US-Eastern:20030210T090000"), #Feb 10, 2003
+      DateTime.parse("US-Eastern:20030310T090000"), #Mar 10, 2003
+    ]
+    
+    te = EveryTE.new(start_date, 2, DPrecision::YEAR) & (REYear.new(1) | REYear.new(2) | REYear.new(3)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 10)
+    assert_equal(expected, results)
+  end
+
+=begin
+  # "Every 3rd year on the 1st, 100th, and 200th day for 10 occurrences"
+  def test_example_23
+    start_date = DateTime.parse("US-Eastern:19970101T090000") #Jan 1, 1997
+    end_date   = DateTime.parse("US-Eastern:20070401T090000") #Apr 1, 2007
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;INTERVAL=3;COUNT=10;BYYEARDAY=1,100,200")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970101T090000"), #Jan 1,  1997
+      DateTime.parse("US-Eastern:19970410T090000"), #Apr 10, 1997
+      DateTime.parse("US-Eastern:19970719T090000"), #Jul 19, 1997
+      DateTime.parse("US-Eastern:20000101T090000"), #Jan 1,  2000
+      DateTime.parse("US-Eastern:20000409T090000"), #Apr 9,  2000
+      DateTime.parse("US-Eastern:20000718T090000"), #Jul 18, 2000
+      DateTime.parse("US-Eastern:20030101T090000"), #Jan 1,  2003
+      DateTime.parse("US-Eastern:20030410T090000"), #Apr 10, 2003
+      DateTime.parse("US-Eastern:20030719T090000"), #Jul 19, 2003
+      DateTime.parse("US-Eastern:20060101T090000"), #Jan 1,  2006
+    ]
+    
+    te = EveryTE.new(start_date, 3, DPrecision::YEAR) & (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 10)
+    assert_equal(expected, results)
+  end
+
+  # "Every 20th Monday of the year, forever"
+  def test_example_24
+    start_date = DateTime.parse("US-Eastern:19970519T090000") #May 19, 1997
+    end_date   = DateTime.parse("US-Eastern:20000101T090000") #Jan 1,  2000
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;BYDAY=20MO")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970519T090000"), #May 19, 1997
+      DateTime.parse("US-Eastern:19980518T090000"), #May 18, 1998
+      DateTime.parse("US-Eastern:19990517T090000"), #May 17, 1999            
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+
+  # "Monday of week number 20 (where the default start of the week is Monday), forever"
+  def test_example_25
+    start_date = DateTime.parse("US-Eastern:19970512T090000") #May 12, 1997
+    end_date   = DateTime.parse("US-Eastern:20000101T090000") #Jan 1,  2000
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;BYWEEKNO=20;BYDAY=MO")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970512T090000"), #May 12, 1997
+      DateTime.parse("US-Eastern:19980511T090000"), #May 11, 1998
+      DateTime.parse("US-Eastern:19990517T090000"), #May 17, 1999            
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 10)
+    assert_equal(expected, results)
+  end
+=end
+
+  # "Every Thursday in March, forever"
+  def test_example_26
+    start_date = DateTime.parse("US-Eastern:19970313T090000") #Mar 13, 1997
+    end_date   = DateTime.parse("US-Eastern:20000101T090000") #Jan 1,  2000
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;BYMONTH=3;BYDAY=TH")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970313T090000"), #Mar 13, 1997
+      DateTime.parse("US-Eastern:19970320T090000"), #Mar 20, 1997
+      DateTime.parse("US-Eastern:19970327T090000"), #Mar 27, 1997
+      DateTime.parse("US-Eastern:19980305T090000"), #Mar 5,  1998
+      DateTime.parse("US-Eastern:19980312T090000"), #Mar 12, 1998
+      DateTime.parse("US-Eastern:19980319T090000"), #Mar 19, 1998
+      DateTime.parse("US-Eastern:19980326T090000"), #Mar 26, 1998
+      DateTime.parse("US-Eastern:19990304T090000"), #Mar 4,  1999
+      DateTime.parse("US-Eastern:19990311T090000"), #Mar 11, 1999            
+      DateTime.parse("US-Eastern:19990318T090000"), #Mar 18, 1999            
+      DateTime.parse("US-Eastern:19990325T090000"), #Mar 25, 1999            
+    ]
+    
+    te = REYear.new(3) & DIWeek.new(Thursday)
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+
+  # "Every Thursday, but only during June, July, and August, forever"
+  def test_example_27
+    start_date = DateTime.parse("US-Eastern:19970605T090000") #Jun 5, 1997
+    end_date   = DateTime.parse("US-Eastern:20000101T090000") #Jan 1, 2000
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;BYDAY=TH;BYMONTH=6,7,8")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970605T090000"), #Jun 5,  1997
+      DateTime.parse("US-Eastern:19970612T090000"), #Jun 12, 1997
+      DateTime.parse("US-Eastern:19970619T090000"), #Jun 19, 1997
+      DateTime.parse("US-Eastern:19970626T090000"), #Jun 26, 1997
+      DateTime.parse("US-Eastern:19970703T090000"), #Jul 3,  1997
+      DateTime.parse("US-Eastern:19970710T090000"), #Jul 10, 1997
+      DateTime.parse("US-Eastern:19970717T090000"), #Jul 17, 1997
+      DateTime.parse("US-Eastern:19970724T090000"), #Jul 24, 1997
+      DateTime.parse("US-Eastern:19970731T090000"), #Jul 31, 1997
+      DateTime.parse("US-Eastern:19970807T090000"), #Aug 7,  1997
+      DateTime.parse("US-Eastern:19970814T090000"), #Aug 14, 1997
+      DateTime.parse("US-Eastern:19970821T090000"), #Aug 21, 1997
+      DateTime.parse("US-Eastern:19970828T090000"), #Aug 28, 1997
+      DateTime.parse("US-Eastern:19980604T090000"), #Jun 4,  1998
+      DateTime.parse("US-Eastern:19980611T090000"), #Jun 11, 1998
+      DateTime.parse("US-Eastern:19980618T090000"), #Jun 18, 1998
+      DateTime.parse("US-Eastern:19980625T090000"), #Jun 25, 1998
+      DateTime.parse("US-Eastern:19980702T090000"), #Jul 2,  1998
+      DateTime.parse("US-Eastern:19980709T090000"), #Jul 9,  1998
+      DateTime.parse("US-Eastern:19980716T090000"), #Jul 16, 1998
+      DateTime.parse("US-Eastern:19980723T090000"), #Jul 23, 1998
+      DateTime.parse("US-Eastern:19980730T090000"), #Jul 30, 1998
+      DateTime.parse("US-Eastern:19980806T090000"), #Aug 6,  1998
+      DateTime.parse("US-Eastern:19980813T090000"), #Aug 13, 1998
+      DateTime.parse("US-Eastern:19980820T090000"), #Aug 20, 1998
+      DateTime.parse("US-Eastern:19980827T090000"), #Aug 27, 1998     
+      DateTime.parse("US-Eastern:19990603T090000"), #Jun 3,  1999
+      DateTime.parse("US-Eastern:19990610T090000"), #Jun 10, 1999
+      DateTime.parse("US-Eastern:19990617T090000"), #Jun 17, 1999
+      DateTime.parse("US-Eastern:19990624T090000"), #Jun 24, 1999
+      DateTime.parse("US-Eastern:19990701T090000"), #Jul 1,  1999
+      DateTime.parse("US-Eastern:19990708T090000"), #Jul 8,  1999
+      DateTime.parse("US-Eastern:19990715T090000"), #Jul 15, 1999
+      DateTime.parse("US-Eastern:19990722T090000"), #Jul 22, 1999
+      DateTime.parse("US-Eastern:19990729T090000"), #Jul 29, 1999
+      DateTime.parse("US-Eastern:19990805T090000"), #Aug 5,  1999
+      DateTime.parse("US-Eastern:19990812T090000"), #Aug 12, 1999
+      DateTime.parse("US-Eastern:19990819T090000"), #Aug 19, 1999
+      DateTime.parse("US-Eastern:19990826T090000"), #Aug 26, 1999       
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7) | REYear.new(8)) & DIWeek.new(Thursday)
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+
+  # "Every Friday the 13th, forever"  
+  # (LJK: aka the "Jason example") (yes, I know it's bad, but someone had to say it)
+  def test_example_28
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997
+    end_date   = DateTime.parse("US-Eastern:20001014T090000") #Oct 14, 2000
+  
+    #rrule = RecurrenceRule.new("FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19980213T090000"), #Feb 13, 1998
+      DateTime.parse("US-Eastern:19980313T090000"), #Mar 13, 1998
+      DateTime.parse("US-Eastern:19981113T090000"), #Nov 13, 1998
+      DateTime.parse("US-Eastern:19990813T090000"), #Aug 13, 1999
+      DateTime.parse("US-Eastern:20001013T090000"), #Oct 13, 2000
+    ]
+    
+    te = REMonth.new(13) & DIWeek.new(Friday)
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+
+  # "The first Saturday that follows the first Sunday of the month, forever"
+  def test_example_29
+    start_date = DateTime.parse("US-Eastern:19970913T090000") #Sep 13, 1997
+    end_date   = DateTime.parse("US-Eastern:19980614T090000") #Jun 14, 1998
+  
+    #rrule = RecurrenceRule.new("FREQ=MONTHLY;BYDAY=SA;BYMONTHDAY=7,8,9,10,11,12,13")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970913T090000"), #Sep 13, 1997
+      DateTime.parse("US-Eastern:19971011T090000"), #Oct 11, 1997
+      DateTime.parse("US-Eastern:19971108T090000"), #Nov 8,  1997
+      DateTime.parse("US-Eastern:19971213T090000"), #Dec 13, 1997
+      DateTime.parse("US-Eastern:19980110T090000"), #Jan 10, 1998
+      DateTime.parse("US-Eastern:19980207T090000"), #Feb 7,  1998
+      DateTime.parse("US-Eastern:19980307T090000"), #Mar 7,  1998
+      DateTime.parse("US-Eastern:19980411T090000"), #Apr 11, 1998
+      DateTime.parse("US-Eastern:19980509T090000"), #May 9,  1998
+      DateTime.parse("US-Eastern:19980613T090000"), #Jun 13, 1998
+    ]
+    
+    te = (REMonth.new(7) | REMonth.new(8) | REMonth.new(9) | REMonth.new(10) | REMonth.new(11) | REMonth.new(12) | REMonth.new(13)) & DIWeek.new(Saturday)
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+  
+  # "Every four years, the first Tuesday after a Monday in November, forever 
+  # (U.S. Presidential Election day)"
+  def test_example_30
+    start_date = DateTime.parse("US-Eastern:19961105T090000") #Nov 11, 1996
+    end_date   = DateTime.parse("US-Eastern:20050101T090000") #Jan 1, 2005
+  
+    #rrule = RecurrenceRule.new("FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19961105T090000"), #Nov 5, 1996
+      DateTime.parse("US-Eastern:20001107T090000"), #Nov 7, 2000
+      DateTime.parse("US-Eastern:20041102T090000"), #Nov 2, 2004            
+    ]
+    
+    te = EveryTE.new(start_date, 4, DPrecision::YEAR) & REYear.new(11) & DIWeek.new(Tuesday) & (REMonth.new(2) | REMonth.new(3) | REMonth.new(4) | REMonth.new(5) | REMonth.new(6) | REMonth.new(7) | REMonth.new(8))
+    results = te.dates(DateRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end  
+
+=begin  
+  # "The 3rd instance into the month of one of Tuesday, Wednesday, or Thursday, for the next three months"
+  def test_example_31
+    start_date = DateTime.parse("US-Eastern:19970904T090000") #Sep 4, 1997
+    end_date   = DateTime.parse("US-Eastern:19971115T090000") #Nov 15, 1997 (LJK: my 22nd birthday)
+  
+    #rrule = RecurrenceRule.new("FREQ=MONTHLY;COUNT=3;BYDAY=TU,WE,TH;BYSETPOS=3")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970904T090000"), #Sep 4, 1997
+      DateTime.parse("US-Eastern:19971007T090000"), #Oct 7, 1997
+      DateTime.parse("US-Eastern:19971106T090000"), #Nov 6, 1997
+    ]
+    
+    te = DIMonth.new(3, Tuesday) | DIMonth.new(3, Wednesday) | DIMonth.new(3,Thursday)
+    results = te.dates(DateRange.new(start_date, end_date), 3)
+    debug(expected, results)
+    assert_equal(expected, results)
+  end
+
+  # "The 2nd to last weekday of the month"
+  def test_example_32
+    start_date = DateTime.parse("US-Eastern:19970929T090000") #Sep 29, 1997
+    end_date   = DateTime.parse("US-Eastern:19980401T090000") #Apr 1,  1998
+  
+    #rrule = RecurrenceRule.new("FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-2")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970929T090000"), #Sep 29, 1997
+      DateTime.parse("US-Eastern:19971030T090000"), #Oct 30, 1997
+      DateTime.parse("US-Eastern:19971127T090000"), #Nov 27, 1997
+      DateTime.parse("US-Eastern:19971230T090000"), #Dec 30, 1997
+      DateTime.parse("US-Eastern:19980129T090000"), #Jan 29, 1998
+      DateTime.parse("US-Eastern:19980226T090000"), #Feb 26, 1998
+      DateTime.parse("US-Eastern:19980330T090000"), #Mar 30, 1998
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 3)
+    assert_equal(expected, results)
+  end
+
+  # "Every 3 hours from 9:00 AM to 5:00 PM on a specific day"
+  def test_example_33
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997 at 9am
+    end_date   = DateTime.parse("US-Eastern:19970902T170000") #Sep 2, 1997 at 5pm
+  
+    #rrule = RecurrenceRule.new("FREQ=HOURLY;INTERVAL=3;UNTIL=19970902T170000Z")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2, 1997 at 9am
+      DateTime.parse("US-Eastern:19970902T120000"), #Sep 2, 1997 at 12pm
+      DateTime.parse("US-Eastern:19970902T150000"), #Sep 2, 1997 at 3pm
+    ]
+    
+    te = EveryTE.new(start_date, 3, DPrecision::HOUR) & BeforeTE.new(DateTime.parse("19970902T170000Z"))
+    results = te.hours(HourRange.new(start_date, end_date))
+    assert_equal(expected, results)
+  end
+
+  # "Every 15 minutes for 6 occurrences"
+  def test_example_34
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997 at 9am
+    end_date   = DateTime.parse("US-Eastern:19970903T090000") #Sep 3, 1997 at 9am
+  
+    #rrule = RecurrenceRule.new("FREQ=MINUTELY;INTERVAL=15;COUNT=6")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2, 1997 at 9:00 am
+      DateTime.parse("US-Eastern:19970902T091500"), #Sep 2, 1997 at 9:15 am
+      DateTime.parse("US-Eastern:19970902T093000"), #Sep 2, 1997 at 9:30 am
+      DateTime.parse("US-Eastern:19970902T094500"), #Sep 2, 1997 at 9:45 am
+      DateTime.parse("US-Eastern:19970902T100000"), #Sep 2, 1997 at 10:00 am
+      DateTime.parse("US-Eastern:19970902T101500"), #Sep 2, 1997 at 10:15 am
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.hours(HourRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+
+  # "Every hour and a half for 4 occurrences"
+  def test_example_35
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997 at 9am
+    end_date   = DateTime.parse("US-Eastern:19970903T090000") #Sep 3, 1997 at 9am
+  
+    #rrule = RecurrenceRule.new("FREQ=MINUTELY;INTERVAL=90;COUNT=4")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2, 1997 at 9:00  am
+      DateTime.parse("US-Eastern:19970902T091500"), #Sep 2, 1997 at 10:30 am
+      DateTime.parse("US-Eastern:19970902T093000"), #Sep 2, 1997 at 12:00 pm
+      DateTime.parse("US-Eastern:19970902T094500"), #Sep 2, 1997 at 1:30  pm
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.hours(HourRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+
+  # "Every 20 minutes from 9:00 AM to 4:40PM every day"
+  # (using a daily rule)
+  def test_example_36_a
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997 at 9am
+    end_date   = DateTime.parse("US-Eastern:19970904T080000") #Sep 4, 1997 at 8am
+  
+    #rrule = RecurrenceRule.new("FREQ=DAILY;BYHOUR=9,10,11,12,13,14,15,16;BYMINUTE=0,20,40")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2, 1997 at 9:00 am
+      DateTime.parse("US-Eastern:19970902T092000"), #Sep 2, 1997 at 9:20 am
+      DateTime.parse("US-Eastern:19970902T094000"), #Sep 2, 1997 at 9:40 am      
+      DateTime.parse("US-Eastern:19970902T100000"), #Sep 2, 1997 at 10:00 am
+      DateTime.parse("US-Eastern:19970902T102000"), #Sep 2, 1997 at 10:20 am
+      DateTime.parse("US-Eastern:19970902T104000"), #Sep 2, 1997 at 10:40 am
+      DateTime.parse("US-Eastern:19970902T110000"), #Sep 2, 1997 at 11:00 am
+      DateTime.parse("US-Eastern:19970902T112000"), #Sep 2, 1997 at 11:20 am
+      DateTime.parse("US-Eastern:19970902T114000"), #Sep 2, 1997 at 11:40 am
+      DateTime.parse("US-Eastern:19970902T120000"), #Sep 2, 1997 at 12:00 pm
+      DateTime.parse("US-Eastern:19970902T122000"), #Sep 2, 1997 at 12:20 pm
+      DateTime.parse("US-Eastern:19970902T124000"), #Sep 2, 1997 at 12:40 pm
+      DateTime.parse("US-Eastern:19970902T130000"), #Sep 2, 1997 at 13:00 pm
+      DateTime.parse("US-Eastern:19970902T132000"), #Sep 2, 1997 at 13:20 pm
+      DateTime.parse("US-Eastern:19970902T134000"), #Sep 2, 1997 at 13:40 pm
+      DateTime.parse("US-Eastern:19970902T140000"), #Sep 2, 1997 at 14:00 pm
+      DateTime.parse("US-Eastern:19970902T142000"), #Sep 2, 1997 at 14:20 pm
+      DateTime.parse("US-Eastern:19970902T144000"), #Sep 2, 1997 at 14:40 pm
+      DateTime.parse("US-Eastern:19970902T150000"), #Sep 2, 1997 at 15:00 pm
+      DateTime.parse("US-Eastern:19970902T152000"), #Sep 2, 1997 at 15:20 pm
+      DateTime.parse("US-Eastern:19970902T154000"), #Sep 2, 1997 at 15:40 pm
+      DateTime.parse("US-Eastern:19970902T160000"), #Sep 2, 1997 at 16:00 pm
+      DateTime.parse("US-Eastern:19970902T162000"), #Sep 2, 1997 at 16:20 pm
+      DateTime.parse("US-Eastern:19970902T164000"), #Sep 2, 1997 at 16:40 pm
+      DateTime.parse("US-Eastern:19970903T090000"), #Sep 3, 1997 at 9:00 am
+      DateTime.parse("US-Eastern:19970903T092000"), #Sep 3, 1997 at 9:20 am
+      DateTime.parse("US-Eastern:19970903T094000"), #Sep 3, 1997 at 9:40 am      
+      DateTime.parse("US-Eastern:19970903T100000"), #Sep 3, 1997 at 10:00 am
+      DateTime.parse("US-Eastern:19970903T102000"), #Sep 3, 1997 at 10:20 am
+      DateTime.parse("US-Eastern:19970903T104000"), #Sep 3, 1997 at 10:40 am
+      DateTime.parse("US-Eastern:19970903T110000"), #Sep 3, 1997 at 11:00 am
+      DateTime.parse("US-Eastern:19970903T112000"), #Sep 3, 1997 at 11:20 am
+      DateTime.parse("US-Eastern:19970903T114000"), #Sep 3, 1997 at 11:40 am
+      DateTime.parse("US-Eastern:19970903T120000"), #Sep 3, 1997 at 12:00 pm
+      DateTime.parse("US-Eastern:19970903T122000"), #Sep 3, 1997 at 12:20 pm
+      DateTime.parse("US-Eastern:19970903T124000"), #Sep 3, 1997 at 12:40 pm
+      DateTime.parse("US-Eastern:19970903T130000"), #Sep 3, 1997 at 13:00 pm
+      DateTime.parse("US-Eastern:19970903T132000"), #Sep 3, 1997 at 13:20 pm
+      DateTime.parse("US-Eastern:19970903T134000"), #Sep 3, 1997 at 13:40 pm
+      DateTime.parse("US-Eastern:19970903T140000"), #Sep 3, 1997 at 14:00 pm
+      DateTime.parse("US-Eastern:19970903T142000"), #Sep 3, 1997 at 14:20 pm
+      DateTime.parse("US-Eastern:19970903T144000"), #Sep 3, 1997 at 14:40 pm
+      DateTime.parse("US-Eastern:19970903T150000"), #Sep 3, 1997 at 15:00 pm
+      DateTime.parse("US-Eastern:19970903T152000"), #Sep 3, 1997 at 15:20 pm
+      DateTime.parse("US-Eastern:19970903T154000"), #Sep 3, 1997 at 15:40 pm
+      DateTime.parse("US-Eastern:19970903T160000"), #Sep 3, 1997 at 16:00 pm
+      DateTime.parse("US-Eastern:19970903T162000"), #Sep 3, 1997 at 16:20 pm
+      DateTime.parse("US-Eastern:19970903T164000"), #Sep 3, 1997 at 16:40 pm
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.hours(HourRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+
+  # "Every 20 minutes from 9:00 AM to 4:40PM every day"
+  # (using a minute-based rule)
+  def test_example_36_b
+    start_date = DateTime.parse("US-Eastern:19970902T090000") #Sep 2, 1997 at 9am
+    end_date   = DateTime.parse("US-Eastern:19970904T080000") #Sep 4, 1997 at 8am
+  
+    #rrule = RecurrenceRule.new("FREQ=MINUTELY;INTERVAL=20;BYHOUR=9,10,11,12,13,14,15,16")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970902T090000"), #Sep 2, 1997 at 9:00 am
+      DateTime.parse("US-Eastern:19970902T092000"), #Sep 2, 1997 at 9:20 am
+      DateTime.parse("US-Eastern:19970902T094000"), #Sep 2, 1997 at 9:40 am      
+      DateTime.parse("US-Eastern:19970902T100000"), #Sep 2, 1997 at 10:00 am
+      DateTime.parse("US-Eastern:19970902T102000"), #Sep 2, 1997 at 10:20 am
+      DateTime.parse("US-Eastern:19970902T104000"), #Sep 2, 1997 at 10:40 am
+      DateTime.parse("US-Eastern:19970902T110000"), #Sep 2, 1997 at 11:00 am
+      DateTime.parse("US-Eastern:19970902T112000"), #Sep 2, 1997 at 11:20 am
+      DateTime.parse("US-Eastern:19970902T114000"), #Sep 2, 1997 at 11:40 am
+      DateTime.parse("US-Eastern:19970902T120000"), #Sep 2, 1997 at 12:00 pm
+      DateTime.parse("US-Eastern:19970902T122000"), #Sep 2, 1997 at 12:20 pm
+      DateTime.parse("US-Eastern:19970902T124000"), #Sep 2, 1997 at 12:40 pm
+      DateTime.parse("US-Eastern:19970902T130000"), #Sep 2, 1997 at 13:00 pm
+      DateTime.parse("US-Eastern:19970902T132000"), #Sep 2, 1997 at 13:20 pm
+      DateTime.parse("US-Eastern:19970902T134000"), #Sep 2, 1997 at 13:40 pm
+      DateTime.parse("US-Eastern:19970902T140000"), #Sep 2, 1997 at 14:00 pm
+      DateTime.parse("US-Eastern:19970902T142000"), #Sep 2, 1997 at 14:20 pm
+      DateTime.parse("US-Eastern:19970902T144000"), #Sep 2, 1997 at 14:40 pm
+      DateTime.parse("US-Eastern:19970902T150000"), #Sep 2, 1997 at 15:00 pm
+      DateTime.parse("US-Eastern:19970902T152000"), #Sep 2, 1997 at 15:20 pm
+      DateTime.parse("US-Eastern:19970902T154000"), #Sep 2, 1997 at 15:40 pm
+      DateTime.parse("US-Eastern:19970902T160000"), #Sep 2, 1997 at 16:00 pm
+      DateTime.parse("US-Eastern:19970902T162000"), #Sep 2, 1997 at 16:20 pm
+      DateTime.parse("US-Eastern:19970902T164000"), #Sep 2, 1997 at 16:40 pm
+      DateTime.parse("US-Eastern:19970903T090000"), #Sep 3, 1997 at 9:00 am
+      DateTime.parse("US-Eastern:19970903T092000"), #Sep 3, 1997 at 9:20 am
+      DateTime.parse("US-Eastern:19970903T094000"), #Sep 3, 1997 at 9:40 am      
+      DateTime.parse("US-Eastern:19970903T100000"), #Sep 3, 1997 at 10:00 am
+      DateTime.parse("US-Eastern:19970903T102000"), #Sep 3, 1997 at 10:20 am
+      DateTime.parse("US-Eastern:19970903T104000"), #Sep 3, 1997 at 10:40 am
+      DateTime.parse("US-Eastern:19970903T110000"), #Sep 3, 1997 at 11:00 am
+      DateTime.parse("US-Eastern:19970903T112000"), #Sep 3, 1997 at 11:20 am
+      DateTime.parse("US-Eastern:19970903T114000"), #Sep 3, 1997 at 11:40 am
+      DateTime.parse("US-Eastern:19970903T120000"), #Sep 3, 1997 at 12:00 pm
+      DateTime.parse("US-Eastern:19970903T122000"), #Sep 3, 1997 at 12:20 pm
+      DateTime.parse("US-Eastern:19970903T124000"), #Sep 3, 1997 at 12:40 pm
+      DateTime.parse("US-Eastern:19970903T130000"), #Sep 3, 1997 at 13:00 pm
+      DateTime.parse("US-Eastern:19970903T132000"), #Sep 3, 1997 at 13:20 pm
+      DateTime.parse("US-Eastern:19970903T134000"), #Sep 3, 1997 at 13:40 pm
+      DateTime.parse("US-Eastern:19970903T140000"), #Sep 3, 1997 at 14:00 pm
+      DateTime.parse("US-Eastern:19970903T142000"), #Sep 3, 1997 at 14:20 pm
+      DateTime.parse("US-Eastern:19970903T144000"), #Sep 3, 1997 at 14:40 pm
+      DateTime.parse("US-Eastern:19970903T150000"), #Sep 3, 1997 at 15:00 pm
+      DateTime.parse("US-Eastern:19970903T152000"), #Sep 3, 1997 at 15:20 pm
+      DateTime.parse("US-Eastern:19970903T154000"), #Sep 3, 1997 at 15:40 pm
+      DateTime.parse("US-Eastern:19970903T160000"), #Sep 3, 1997 at 16:00 pm
+      DateTime.parse("US-Eastern:19970903T162000"), #Sep 3, 1997 at 16:20 pm
+      DateTime.parse("US-Eastern:19970903T164000"), #Sep 3, 1997 at 16:40 pm
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.hours(HourRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+
+  # "An example where the days generated makes a difference because of WKST"
+  # (start of week day == Monday)
+  def test_example_37_a
+    start_date = DateTime.parse("US-Eastern:19970805T090000") #Aug 5, 1997
+    end_date   = DateTime.parse("US-Eastern:19970901T080000") #Sep 1, 1997
+  
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;INTERVAL=2;COUNT=4;BYDAY=TU,SU;WKST=MO")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970805T090000"), #Aug 5,  1997
+      DateTime.parse("US-Eastern:19970810T090000"), #Aug 10, 1997
+      DateTime.parse("US-Eastern:19970819T090000"), #Aug 19, 1997
+      DateTime.parse("US-Eastern:19970824T090000"), #Aug 24, 1997
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+  
+  # "An example where the days generated makes a difference because of WKST"
+  # (start of week day == Sunday)
+  def test_example_37_b
+    start_date = DateTime.parse("US-Eastern:19970805T090000") #Aug 5, 1997
+    end_date   = DateTime.parse("US-Eastern:19970901T080000") #Sep 1, 1997
+  
+    #rrule = RecurrenceRule.new("FREQ=WEEKLY;INTERVAL=2;COUNT=4;BYDAY=TU,SU;WKST=SU")
+  
+    expected = [
+      DateTime.parse("US-Eastern:19970805T090000"), #Aug 5,  1997
+      DateTime.parse("US-Eastern:19970817T090000"), #Aug 17, 1997
+      DateTime.parse("US-Eastern:19970819T090000"), #Aug 19, 1997
+      DateTime.parse("US-Eastern:19970831T090000"), #Aug 31, 1997
+    ]
+    
+    te = (REYear.new(6) | REYear.new(7)) & REMonth.new(start_date.day)
+    results = te.dates(DateRange.new(start_date, end_date), 6)
+    assert_equal(expected, results)
+  end
+=end
+
   def debug(expected, results)
     puts "expected:"
     expected.each {|date| puts date}
Index: test/pdatetest.rb
===================================================================
--- test/pdatetest.rb	(revision 179)
+++ test/pdatetest.rb	(working copy)
@@ -16,6 +16,8 @@
     #August, 2004
     @month_prec = PDate.month(2004,8)
     #January 25th, 2004 (11:39 am - ignored)
+    @week_prec = PDate.week(2004,1,25,11,39)
+    #January 25th, 2004 (11:39 am - ignored)
     @day_prec = PDate.day(2004,1,25,11,39)
     #11:59(:04 - ignored), December 31st, 1999
     @minute_prec = PDate.min(1999,12,31,23,59,4)
@@ -53,6 +55,7 @@
   def test_plus
     assert(PDate.year(2022,12)==(@year_prec+12))
     assert(PDate.month(2005,2)==(@month_prec+6))
+    assert(PDate.week(2004,2,1)==(@week_prec+1))
     assert(PDate.day(2004,2,1)==(@day_prec+7))
     assert(PDate.min(2000,1,1,0,0)==(@minute_prec+1))
     assert(PDate.sec(2004,3,1,0,0,21)==(@second_prec+11))
@@ -61,6 +64,7 @@
   def test_minus
     assert(PDate.year(1998,12)==(@year_prec-12))
     assert(PDate.month(2002,6)==(@month_prec-26))
+    assert(PDate.week(2004,1,11)==(@week_prec-2))    
     #Hmmm...FIXME? @day_prec-26 == 12/31??
     assert(PDate.day(2003,12,30)==(@day_prec-26))
     assert(PDate.min(1999,12,31,21,57)==(@minute_prec-122))
@@ -70,6 +74,7 @@
     sec_prec = PDate.sec(2002,8,28,6,04,02)
     assert(PDate.year(1998,12)<sec_prec)
     assert(PDate.month(2002,9)>sec_prec)
+    assert(PDate.week(2002,8,28)==sec_prec)
     assert(PDate.day(2002,8,28)==sec_prec)
     assert(PDate.min(1999,12,31,21,57)<sec_prec)
     assert(DateTime.new(2002,8,28,6,04,02)==sec_prec)
@@ -113,5 +118,30 @@
     #December 2003
     month_prec4 = PDate.month(2003,12)
     assert(month_prec4!=month_prec1, "PDate.month instances not equal.")
+
+    one_week = [
+      PDate.week(2004, 12, 20), # Monday
+      PDate.week(2004, 12, 21), # Tuesday
+      PDate.week(2004, 12, 22), # Wednesday
+      PDate.week(2004, 12, 23), # Thursday
+      PDate.week(2004, 12, 24), # Friday
+      PDate.week(2004, 12, 25), # Saturday
+      PDate.week(2004, 12, 26), # Sunday
+    ]
+
+    one_week.each do |week_prec1|
+      one_week.each do |week_prec2|
+        assert_equal week_prec1, week_prec2
+      end
+    end
+
+    week_before = PDate.week(2004, 12, 19)
+    week_after  = PDate.week(2004, 12, 27)
+        
+    one_week.each do |week_prec|
+      assert week_prec != week_before
+      assert week_prec != week_after
+    end
   end
+  
 end
Index: test/dprecisiontest.rb
===================================================================
--- test/dprecisiontest.rb	(revision 179)
+++ test/dprecisiontest.rb	(working copy)
@@ -14,7 +14,8 @@
 
   def test_comparable
     assert(DPrecision::YEAR<DPrecision::MONTH, "DPrecision.year was not less than DPrecision.month")
-    assert(DPrecision::MONTH<DPrecision::DAY, "DPrecision.month was not less than DPrecision.day")
+    assert(DPrecision::MONTH<DPrecision::WEEK, "DPrecision.month was not less than DPrecision.week")
+    assert(DPrecision::WEEK<DPrecision::DAY, "DPrecision.week was not less than DPrecision.day")
     assert(DPrecision::DAY<DPrecision::HOUR, "DPrecision.day was not less than DPrecision.hour")
     assert(DPrecision::HOUR<DPrecision::MIN, "DPrecision.hour was not less than DPrecision.min")
     assert(DPrecision::MIN<DPrecision::SEC, "DPrecision.min was not less than DPrecision.sec")
@@ -24,6 +25,7 @@
   def test_pseudo_singleton_instance
     assert(DPrecision::YEAR.object_id==DPrecision::YEAR.object_id, "Object Id's not equal.")
     assert(DPrecision::MONTH.object_id==DPrecision::MONTH.object_id, "Object Id's not equal.")
+    assert(DPrecision::WEEK.object_id==DPrecision::WEEK.object_id, "Object Id's not equal.")
     assert(DPrecision::DAY.object_id==DPrecision::DAY.object_id, "Object Id's not equal.")
     assert(DPrecision::HOUR.object_id==DPrecision::HOUR.object_id, "Object Id's not equal.")
     assert(DPrecision::MIN.object_id==DPrecision::MIN.object_id, "Object Id's not equal.")
@@ -45,6 +47,7 @@
   def test_label
     assert_equal(DPrecision::YEAR.label,"YEAR")
     assert_equal(DPrecision::MONTH.label,"MONTH")
+    assert_equal(DPrecision::WEEK.label,"WEEK")
     assert_equal(DPrecision::DAY.label,"DAY")
     assert_equal(DPrecision::HOUR.label,"HOUR")
     assert_equal(DPrecision::MIN.label,"MINUTE")
Index: lib/runt/pdate.rb
===================================================================
--- lib/runt/pdate.rb	(revision 179)
+++ lib/runt/pdate.rb	(working copy)
@@ -50,6 +50,8 @@
       when MONTH then
 	current_date = self.class.to_date(self)
 	return DPrecision::to_p((current_date>>n),@date_precision)
+      when WEEK then
+	return new_self_plus(n*7)	
       when DAY then
 	return new_self_plus(n)
       when HOUR then
@@ -106,6 +108,16 @@
     PDate.civil(MONTH, yr, mon, DAY.min_value  )
   end
 
+  def PDate.week( yr,mon,day,*ignored )
+    #LJK: need to calculate which week this day implies,
+    #and then move the day back to the *first* day in that week;
+    #note that since rfc2445 defaults to weekstart=monday, I'm 
+    #going to use commercial day-of-week
+    raw = PDate.day(yr, mon, day)
+    cooked = PDate.commercial(raw.cwyear, raw.cweek, 1)
+    PDate.civil(WEEK, cooked.year, cooked.month, cooked.day)
+  end
+
   def PDate.day( yr,mon,day,*ignored )
     PDate.civil(DAY, yr, mon, day )
   end
Index: lib/runt/dprecision.rb
===================================================================
--- lib/runt/dprecision.rb	(revision 179)
+++ lib/runt/dprecision.rb	(working copy)
@@ -21,6 +21,7 @@
         when MIN then PDate.min(*DPrecision.explode(date,prec))
         when DAY then PDate.day(*DPrecision.explode(date,prec))
         when HOUR then PDate.hour(*DPrecision.explode(date,prec))
+        when WEEK then PDate.week(*DPrecision.explode(date,prec))
         when MONTH then PDate.month(*DPrecision.explode(date,prec))
         when YEAR then PDate.year(*DPrecision.explode(date,prec))
         when SEC then PDate.sec(*DPrecision.explode(date,prec))
@@ -49,15 +50,17 @@
       #Some constants w/arbitrary integer values used internally for comparisions
       YEAR_PREC = 0
       MONTH_PREC = 1
-      DAY_PREC = 2
-      HOUR_PREC = 3
-      MIN_PREC = 4
-      SEC_PREC = 5
-      MILLI_PREC = 6
+      WEEK_PREC = 2
+      DAY_PREC = 3
+      HOUR_PREC = 4
+      MIN_PREC = 5
+      SEC_PREC = 6
+      MILLI_PREC = 7
 
       #String values for display
       LABEL = { YEAR_PREC => "YEAR",
         MONTH_PREC => "MONTH",
+        WEEK_PREC => "WEEK",
         DAY_PREC => "DAY",
         HOUR_PREC => "HOUR",
         MIN_PREC => "MINUTE",
@@ -67,6 +70,7 @@
       #Minimun values that precisioned fields get set to
       FIELD_MIN = { YEAR_PREC => 1,
       MONTH_PREC => 1,
+      WEEK_PREC => 1,
       DAY_PREC => 1,
       HOUR_PREC => 0,
       MIN_PREC => 0,
@@ -81,6 +85,10 @@
         new(MONTH_PREC)
       end
 
+      def Precision.week
+        new(WEEK_PREC)
+      end 
+      
       def Precision.day
         new(DAY_PREC)
       end
@@ -122,13 +130,14 @@
       end
 
       def label
-	LABEL[@precision]
+        LABEL[@precision]
       end
   end
 
   #Pseudo Singletons:
   YEAR = Precision.year
   MONTH = Precision.month
+  WEEK = Precision.week
   DAY = Precision.day
   HOUR = Precision.hour
   MIN = Precision.min
Index: lib/runt/temporalexpression.rb
===================================================================
--- lib/runt/temporalexpression.rb	(revision 179)
+++ lib/runt/temporalexpression.rb	(working copy)
@@ -668,24 +668,25 @@
 
   include TExpr
 
-  def initialize(start,n)
+  def initialize(start,n,precision=nil)
     @start=start
     @interval=n
+    # Use the precision of the start date by default
+    @precision=precision || @start.date_precision
   end
 
   def include?(date)
-    i=DPrecision.to_p(@start,@start.date_precision)
-    # Use the precision of the start date
-    d=DPrecision.to_p(date,@start.date_precision)
+    i=DPrecision.to_p(@start,@precision)
+    d=DPrecision.to_p(date,@precision)
     while i<=d
       return true if i.eql?(d)
-      i=i+@interval
+      i=i+@interval      
     end
     false
   end
 
   def to_s
-    "every #{@interval} #{@start.date_precision.label.downcase}s starting #{Runt.format_date(@start)}"
+    "every #{@interval} #{@precision.label.downcase}s starting #{Runt.format_date(@start)}"
   end
 
 end