runt 0.6.0 → 0.7.0

data/test/beforetetest.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for BeforeTE class
+# Author:: Matthew Lipper
+
+class BeforeTETest < BaseExpressionTest
+
+  include TExpr
+
+  def test_include_inclusive
+    expr = BeforeTE.new(@pdate_20071030, true)
+    assert expr.include?(@date_20050101), "Should include an earlier date"
+    assert !expr.include?(@pdate_20071114), "Should not include a later date"
+    assert expr.include?(@pdate_20071030), "Should include the same date"
+  end
+
+  def test_include_non_inclusive
+    expr = BeforeTE.new(@pdate_20071030)
+    assert expr.include?(@date_20050101), "Should include an earlier date"
+    assert !expr.include?(@pdate_20071114), "Should not include a later date"
+    assert !expr.include?(@pdate_20071030), "Should not include the same date"
+  end
+
+  def test_to_s
+    expr = BeforeTE.new(@pdate_20071114)
+    assert_equal "before #{Runt.format_date(@pdate_20071114)}", expr.to_s
+  end
+
+end

data/test/daterangetest.rb

@@ -1,89 +1,89 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'runt'
-require 'date'
-
-# Unit tests for DateRange class
-#
-# Author:: Matthew Lipper
-class DateRangeTest < Test::Unit::TestCase
-
-  include Runt
-
-  def test_sub_range
-    r_start = PDate.sec(2004,2,29,16,24,12)
-    r_end = PDate.sec(2004,3,2,4,22,58)
-    range = DateRange.new(r_start,r_end)
-    assert(range.min==r_start)
-    assert(range.max==r_end)
-    assert(range.include?(r_start+1))
-    assert(range.include?(r_end-1))
-    sub_range = DateRange.new((r_start+1),(r_end-1))
-    assert(range.include?(sub_range))
-  end
-
-  def test_date
-    r_start = PDate.min(1979,12,31,23,57)
-    r_end = PDate.min(1980,1,1,0,2)
-    range = DateRange.new(r_start,r_end)
-    assert(range.min==r_start)
-    assert(range.max==r_end)
-    assert(range.include?(r_start+1))
-    assert(range.include?(r_end-1))
-    sub_range = DateRange.new((r_start+1),(r_end-1))
-    assert(range.include?(sub_range))
-  end
-
-  def test_spaceship_operator
-    r_start = PDate.min(1984,8,31,22,00)
-    r_end = PDate.min(1984,9,15,0,2)
-    range = DateRange.new(r_start,r_end)
-    assert(-1==(range<=>(DateRange.new(r_start+2,r_end+5))))
-    assert(1==(range<=>(DateRange.new(r_start-24,r_end+5))))
-    assert(0==(range<=>(DateRange.new(r_start,r_end))))
-  end
-
-  def test_overlap
-    r_start = PDate.month(2010,12)
-    r_end = PDate.month(2011,12)
-    range = DateRange.new(r_start,r_end)
-    o_start = PDate.month(2010,11)
-    o_end = PDate.month(2012,2)
-    o_range = DateRange.new(o_start,o_end)
-    assert(range.overlap?(o_range))
-    assert(o_range.overlap?(range))
-    assert(o_range.overlap?(DateRange.new(r_start,o_end)))
-    assert(o_range.overlap?(DateRange.new(o_start,r_end)))
-        
-    # September 18th - 19th, 2005, 8am - 10am 
-    expr1=DateRange.new(PDate.day(2005,9,18),PDate.day(2005,9,19)) 
-    # September 19th - 20th, 2005, 9am - 11am 
-    expr2=DateRange.new(PDate.day(2005,9,19),PDate.day(2005,9,20))
-
-    assert(expr1.overlap?(expr2))
-  end
-
-  def test_empty
-    r_start = PDate.hour(2004,2,10,0)
-    r_end = PDate.hour(2004,2,9,23)
-    empty_range = DateRange.new(r_start,r_end)
-    assert(empty_range.empty?)
-    assert(DateRange::EMPTY.empty?)
-    # start == end should be empty
-    assert DateRange.new(r_start,r_start).empty?, "Range should be empty when start == end"
-  end
-
-  def test_gap
-    r_start = PDate.day(2000,6,12)
-    r_end = PDate.day(2000,6,14)
-    range = DateRange.new(r_start,r_end)
-    g_start = PDate.day(2000,6,18)
-    g_end = PDate.day(2000,6,20)
-    g_range = DateRange.new(g_start,g_end)
-    the_gap=range.gap(g_range)
-    assert(the_gap.start_expr==(r_end+1))
-    assert(the_gap.end_expr==(g_start-1))
-  end
-
-end
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'date'
+
+# Unit tests for DateRange class
+#
+# Author:: Matthew Lipper
+class DateRangeTest < Test::Unit::TestCase
+
+  include Runt
+
+  def test_sub_range
+    r_start = PDate.sec(2004,2,29,16,24,12)
+    r_end = PDate.sec(2004,3,2,4,22,58)
+    range = DateRange.new(r_start,r_end)
+    assert(range.min==r_start)
+    assert(range.max==r_end)
+    assert(range.include?(r_start+1))
+    assert(range.include?(r_end-1))
+    sub_range = DateRange.new((r_start+1),(r_end-1))
+    assert(range.include?(sub_range))
+  end
+
+  def test_date
+    r_start = PDate.min(1979,12,31,23,57)
+    r_end = PDate.min(1980,1,1,0,2)
+    range = DateRange.new(r_start,r_end)
+    assert(range.min==r_start)
+    assert(range.max==r_end)
+    assert(range.include?(r_start+1))
+    assert(range.include?(r_end-1))
+    sub_range = DateRange.new((r_start+1),(r_end-1))
+    assert(range.include?(sub_range))
+  end
+
+  def test_spaceship_operator
+    r_start = PDate.min(1984,8,31,22,00)
+    r_end = PDate.min(1984,9,15,0,2)
+    range = DateRange.new(r_start,r_end)
+    assert(-1==(range<=>(DateRange.new(r_start+2,r_end+5))))
+    assert(1==(range<=>(DateRange.new(r_start-24,r_end+5))))
+    assert(0==(range<=>(DateRange.new(r_start,r_end))))
+  end
+
+  def test_overlap
+    r_start = PDate.month(2010,12)
+    r_end = PDate.month(2011,12)
+    range = DateRange.new(r_start,r_end)
+    o_start = PDate.month(2010,11)
+    o_end = PDate.month(2012,2)
+    o_range = DateRange.new(o_start,o_end)
+    assert(range.overlap?(o_range))
+    assert(o_range.overlap?(range))
+    assert(o_range.overlap?(DateRange.new(r_start,o_end)))
+    assert(o_range.overlap?(DateRange.new(o_start,r_end)))
+        
+    # September 18th - 19th, 2005, 8am - 10am 
+    expr1=DateRange.new(PDate.day(2005,9,18),PDate.day(2005,9,19)) 
+    # September 19th - 20th, 2005, 9am - 11am 
+    expr2=DateRange.new(PDate.day(2005,9,19),PDate.day(2005,9,20))
+
+    assert(expr1.overlap?(expr2))
+  end
+
+  def test_empty
+    r_start = PDate.hour(2004,2,10,0)
+    r_end = PDate.hour(2004,2,9,23)
+    empty_range = DateRange.new(r_start,r_end)
+    assert(empty_range.empty?)
+    assert(DateRange::EMPTY.empty?)
+    # start == end should be empty
+    assert DateRange.new(r_start,r_start).empty?, "Range should be empty when start == end"
+  end
+
+  def test_gap
+    r_start = PDate.day(2000,6,12)
+    r_end = PDate.day(2000,6,14)
+    range = DateRange.new(r_start,r_end)
+    g_start = PDate.day(2000,6,18)
+    g_end = PDate.day(2000,6,20)
+    g_range = DateRange.new(g_start,g_end)
+    the_gap=range.gap(g_range)
+    assert(the_gap.start_expr==(r_end+1))
+    assert(the_gap.end_expr==(g_start-1))
+  end
+
+end

data/test/dprecisiontest.rb

@@ -1,55 +1,58 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'runt'
-require 'date'
-
-# Unit tests for DPrecision class
-#
-# Author:: Matthew Lipper
-
-class DPrecisionTest < Test::Unit::TestCase
-
-  include Runt
-
-  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::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")
-    assert(DPrecision::SEC<DPrecision::MILLI, "DPrecision.sec was not less than DPrecision.millisec")
-  end
-
-  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::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.")
-    assert(DPrecision::SEC.object_id==DPrecision::SEC.object_id, "Object Id's not equal.")
-    assert(DPrecision::MILLI.object_id==DPrecision::MILLI.object_id, "Object Id's not equal.")
-  end
-
-  def test_to_precision
-    #February 29th, 2004
-    no_prec_date = PDate.civil(2004,2,29)
-    month_prec = PDate.month(2004,2,29)
-    assert(month_prec==DPrecision.to_p(no_prec_date,DPrecision::MONTH))
-    #11:59:59 am, February 29th, 2004
-    no_prec_datetime = PDate.civil(2004,2,29,23,59,59)
-    #puts "-->#{no_prec_datetime.date_precision}<--"
-    assert(month_prec==DPrecision.to_p(no_prec_datetime,DPrecision::MONTH))
-  end
-
-  def test_label
-    assert_equal(DPrecision::YEAR.label,"YEAR")
-    assert_equal(DPrecision::MONTH.label,"MONTH")
-    assert_equal(DPrecision::DAY.label,"DAY")
-    assert_equal(DPrecision::HOUR.label,"HOUR")
-    assert_equal(DPrecision::MIN.label,"MINUTE")
-    assert_equal(DPrecision::SEC.label,"SECOND")
-    assert_equal(DPrecision::MILLI.label,"MILLISECOND")
-  end
-
-end
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'date'
+
+# Unit tests for DPrecision class
+#
+# Author:: Matthew Lipper
+
+class DPrecisionTest < Test::Unit::TestCase
+
+  include Runt
+
+  def test_comparable
+    assert(DPrecision::YEAR<DPrecision::MONTH, "DPrecision.year was not less than DPrecision.month")
+    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")
+    assert(DPrecision::SEC<DPrecision::MILLI, "DPrecision.sec was not less than DPrecision.millisec")
+  end
+
+  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.")
+    assert(DPrecision::SEC.object_id==DPrecision::SEC.object_id, "Object Id's not equal.")
+    assert(DPrecision::MILLI.object_id==DPrecision::MILLI.object_id, "Object Id's not equal.")
+  end
+
+  def test_to_precision
+    #February 29th, 2004
+    no_prec_date = PDate.civil(2004,2,29)
+    month_prec = PDate.month(2004,2,29)
+    assert(month_prec==DPrecision.to_p(no_prec_date,DPrecision::MONTH))
+    #11:59:59 am, February 29th, 2004
+    no_prec_datetime = PDate.civil(2004,2,29,23,59,59)
+    #puts "-->#{no_prec_datetime.date_precision}<--"
+    assert(month_prec==DPrecision.to_p(no_prec_datetime,DPrecision::MONTH))
+  end
+
+  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")
+    assert_equal(DPrecision::SEC.label,"SECOND")
+    assert_equal(DPrecision::MILLI.label,"MILLISECOND")
+  end
+
+end

data/test/expressionbuildertest.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+
+class ExpressionBuilderTest < Test::Unit::TestCase
+
+  def setup
+    @builder = ExpressionBuilder.new
+  end
+
+  def test_define_should_instance_eval_a_block
+    @builder.define do
+      @ctx = "meow"
+    end
+    assert_equal "meow", @builder.ctx, "Expected instance variable @ctx to be set by block"  
+  end
+  
+  def test_add_should_initialize_empty_ctx_with_expression
+    result = @builder.add('expr',:to_s)
+    assert_equal 'expr', result, "Result should equal string given to add method"
+    assert_equal 'expr', @builder.ctx, "Builder context should equal result"
+  end
+
+  def test_add_should_send_op_to_ctx_with_expression
+    @builder.add('abc',:to_s)
+    result = @builder.add('def',:concat)
+    assert_equal 'abcdef', result, "Result should equal concatenated strings given to add method"
+    assert_equal 'abcdef', @builder.ctx, "Builder context should equal result"
+  end
+
+  def test_on_should_call_add_with_expression_and_ampersand
+    @builder.add(1,:to_s)
+    result = @builder.on(3) # result = 1 & 3
+    assert_equal 1, result, "Result should equal 1 == 1 & 3"
+    assert_equal 1, @builder.ctx, "Builder context should equal result"
+  end
+
+  def test_except_should_call_add_with_expression_and_minus
+    @builder.add(1,:to_s)
+    result = @builder.except(3) # result = 1 - 3
+    assert_equal -2, result, "Result should equal -2 == 1 - 3"
+    assert_equal -2, @builder.ctx, "Builder context should equal result"
+  end
+
+  def test_possibly_should_call_add_with_expression_and_pipe
+    @builder.add(1, :to_s)
+    result = @builder.possibly(2) # result = 1 | 2
+    assert_equal 3, result, "Result should equal 3 == 1 | 2"
+    assert_equal 3, @builder.ctx, "Builder context should equal result"
+  end
+  
+  def test_builder_created_expression_should_equal_manually_created_expression
+    manual = Runt::REDay.new(8,45,9,30) & Runt::DIWeek.new(Runt::Friday) | \
+      Runt::DIWeek.new(Runt::Saturday) -  Runt::DIMonth.new(Runt::Last, Runt::Friday)
+    expression = @builder.define do
+      on daily_8_45am_to_9_30am
+      on friday
+      possibly saturday
+      except last_friday
+    end
+    assert_equal manual.to_s, expression.to_s, "Expected #{manual.to_s} but was #{expression.to_s}"
+  end
+end

data/test/icalendartest.rb

@@ -63,9 +63,7 @@ class ICalendarTest < Test::Unit::TestCase
       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 @@ class ICalendarTest < Test::Unit::TestCase
       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,11 +132,12 @@ class ICalendarTest < Test::Unit::TestCase
     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
@@ -154,15 +151,18 @@ class ICalendarTest < Test::Unit::TestCase
       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
@@ -183,19 +183,44 @@ class ICalendarTest < Test::Unit::TestCase
       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
@@ -209,15 +234,18 @@ class ICalendarTest < Test::Unit::TestCase
       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 @@ class ICalendarTest < Test::Unit::TestCase
       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 @@ class ICalendarTest < Test::Unit::TestCase
       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 @@ class ICalendarTest < Test::Unit::TestCase
       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 = REMonth.new(10,15) & EveryTE.new(start_date, 18, DPrecision::MONTH)  #tenth through the fifteenth
     results = te.dates(DateRange.new(start_date, end_date), 10)
     assert_equal(expected, results)
   end
@@ -458,21 +540,19 @@ class ICalendarTest < Test::Unit::TestCase
       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 @@ class ICalendarTest < Test::Unit::TestCase
       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 = REMonth.new(start_date.day) & (REYear.new(1) | REYear.new(2) | REYear.new(3)) & EveryTE.new(start_date, 2, DPrecision::YEAR)
+    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") #May 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 = (REMonth.new(2) | REMonth.new(3) | REMonth.new(4) | REMonth.new(5) | REMonth.new(6) | REMonth.new(7) | REMonth.new(8)) & DIWeek.new(Tuesday) & REYear.new(11) & EveryTE.new(start_date, 4, DPrecision::YEAR) 
+    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}