runt19 0.7.6

data/test/combinedexpressionstest.rb

@@ -0,0 +1,158 @@
+
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for composite temporal expressions
+# Author:: Matthew Lipper
+
+class CombinedExpressionTest < BaseExpressionTest
+
+  def test_dates_on_last_fri_or_first_tues
+    date_range = @date_20050101..@date_20051231
+    expr = DIMonth.new(Last, Friday) | DIMonth.new(First, Tuesday)
+    dates = expr.dates(date_range)
+    assert_equal 24, dates.size, "Expected 24 dates in 2005 which were either on the last Friday or first Tuesday of the month"
+    month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] 
+    dates.each do |d|
+      unless (d.wday == 2 and d.day < 8) or \
+	(d.wday == 5 and d.day > month_days[d.month-1] - 8)
+	# Fail
+        assert false, d.to_s 
+      end
+    end
+  end
+
+  def test_january_except_from_7th_to_15th
+    date_range = @date_20050101..@date_20050131
+    dates = (REYear.new(1, 1, 1, 31) - REMonth.new(7, 15)).dates(date_range)
+    assert_equal 22, dates.size, "Expected 22 dates: 1/1-1/6, 1/16-1/31"
+  end
+
+  def test_work_day
+    # Should match for 9am to 5pm except for 12pm to 1pm
+    expr = REDay.new(9,0,17,0) - REDay.new(12,0,13,0)
+    assert expr.include?(@pdate_200405030906), "Expression #{expr.to_s} should include #{@pdate_200405030906.to_s}"
+    assert !expr.include?(@pdate_1975060512), "Expression #{expr.to_s} should not include #{@pdate_1975060512.to_s}"
+  end
+
+  def test_monday_tuesday_8am_to_9am
+    expr = REWeek.new(Mon,Fri) & REDay.new(8,0,9,0)
+    assert expr.include?(@pdate_200405040806), "Expression #{expr.to_s} should include #{@pdate_200405040806.to_s}"
+    assert !expr.include?(@pdate_200405010806), "Expression #{expr.to_s} should not include #{@pdate_200405010806.to_s}"
+    assert !expr.include?(@pdate_200405030906), "Expression #{expr.to_s} should not include #{@pdate_200405030906.to_s}"
+  end
+  
+
+  def test_midnight_to_9am_or_tuesday
+    expr = REDay.new(0,0,9,0) | DIWeek.new(Tuesday)
+    assert expr.include?(@pdate_20071030), "Expression #{expr.to_s} should include #{@pdate_20071030.to_s}"
+    assert expr.include?(@pdate_2012050803), "Expression #{expr.to_s} should include #{@pdate_2012050803.to_s}"
+    assert !expr.include?(@pdate_20071116100030), "Expression #{expr.to_s} should not include #{@pdate_20071116100030.to_s}"
+  end
+
+  def test_wednesday_thru_saturday_6_to_12am
+    expr = REWeek.new(Wed, Sat) & REDay.new(6,0,12,00)
+    assert !expr.include?(@time_20070926000000), "Expression #{expr.to_s} should include #{@time_20070926000000.to_s}"
+    assert expr.include?(@time_20070927065959), "Expression #{expr.to_s} should include #{@time_20070927065959.to_s}"
+    assert !expr.include?(@time_20070928000000), "Expression #{expr.to_s} should include #{@time_20070928000000.to_s}"
+    assert expr.include?(@time_20070929110000), "Expression #{expr.to_s} should include #{@time_20070929110000.to_s}"
+  end
+
+  def test_memorial_day
+    # Monday through Friday, from 9am to 5pm
+    job = REWeek.new(Mon,Fri) & REDay.new(9,00,17,00)
+    # Memorial Day (U.S.)
+    memorial_day = REYear.new(5) & DIMonth.new(Last,Monday)
+    # May 29th, 2006
+    last_monday_in_may = @pdate_200605291012
+    # Before 
+    assert job.include?(last_monday_in_may), "Expression #{job.to_s} should include #{last_monday_in_may.to_s}"
+    assert job.include?(@pdate_200605301400), "Expression #{job.to_s} should include #{@pdate_200605301400.to_s}"
+    # Add Diff expression
+    job_with_holiday = job - last_monday_in_may
+    assert !job_with_holiday.include?(last_monday_in_may), "Expression #{job_with_holiday.to_s} should not include #{last_monday_in_may.to_s}"
+    # Still have to work on Tuesday
+    assert job.include?(@pdate_200605301400), "Expression #{job.to_s} should include #{@pdate_200605301400.to_s}"
+  end
+  
+  def test_summertime
+    #This is a hack.....
+    #In the U.S., Memorial Day begins the last Monday of May
+    #
+    #The month of May
+    may=REYear.new(5)
+    #Monday through Saturday
+    monday_to_saturday = REWeek.new(1,6)
+    #Last week of (any) month
+    last_week_in = WIMonth.new(Last_of)
+    #So, to say 'starting from the last Monday in May',
+    #we need to select just that last week of May begining with
+    #the Monday of that week
+    last_week_of_may = may & monday_to_saturday & last_week_in
+
+    #This is another hack similar to the above, except instead of selecting a range
+    #starting at the begining of the month, we need to select only the time period in
+    #September up until Labor Day.
+    #
+    #In the U.S., Labor Day is the first Monday in September
+    #
+    #The month of September
+    september=REYear.new(9)
+    #First week of (any) month
+    first_week_in = WIMonth.new(First)
+    entire_first_week_of_september = september & first_week_in
+    #To exclude everything in the first week which occurs on or after Monday.
+    first_week_of_september=entire_first_week_of_september - monday_to_saturday
+    #June through August
+    june_through_august=REYear.new(6, 1, 8)
+    assert june_through_august.include?(@pdate_20040704), "Expression #{june_through_august.to_s} should include #{@pdate_20040704.to_s}"
+    #Finally!
+    summer_time = last_week_of_may | first_week_of_september | june_through_august
+
+    #Will work, but will be incredibly slow:
+    #  assert(summer_time.include?(PDate.min(2004,5,31,0,0)))
+    assert summer_time.include?(@pdate_20040531), "Expression #{summer_time.to_s} should include #{@pdate_20040704.to_s}"
+    assert summer_time.include?(@pdate_20040704), "Expression #{summer_time.to_s} should include #{@pdate_20040704.to_s}"
+    #also works...also slow:
+    #  assert(!summer_time.include?(PDate.min(2004,9,6,0,0)))
+    assert !summer_time.include?(@pdate_2004090600), "Expression #{summer_time.to_s} should not include #{@pdate_2004090600.to_s}"
+
+  end
+  def test_nyc_parking_te
+
+    #Monday, Wednesday, Friday
+    mon_wed_fri = DIWeek.new(Mon) | \
+                    DIWeek.new(Wed) | \
+                      DIWeek.new(Fri)
+
+    assert mon_wed_fri.include?(@datetime_200403101915), "Expression #{mon_wed_fri.to_s} should include #{@datetime_200403101915.to_s}"
+    assert !mon_wed_fri.include?(@datetime_200403140900), "Expression #{mon_wed_fri.to_s} should not include #{@datetime_200403140900.to_s}"
+    # 8am to 11am
+    eight_to_eleven = REDay.new(8,00,11,00)
+    # => Mon,Wed,Fri - 8am to 11am
+    expr1 = mon_wed_fri & eight_to_eleven
+    # Tuesdays, Thursdays
+    tues_thurs = DIWeek.new(Tue) | DIWeek.new(Thu)
+    # 11:30am to 2pm
+    eleven_thirty_to_two = REDay.new(11,30,14,00)
+    assert eleven_thirty_to_two.include?(@datetime_200403081200), "Expression #{eleven_thirty_to_two.to_s} should include #{@datetime_200403081200.to_s}"
+    assert !eleven_thirty_to_two.include?(@datetime_200403110000), "Expression #{eleven_thirty_to_two.to_s} should not include #{@datetime_200403110000.to_s}"
+    # => Tues,Thurs - 11:30am to 2pm
+    expr2 = tues_thurs & eleven_thirty_to_two
+    #
+    # No parking: Mon Wed Fri, 8am - 11am
+    #             Tu Thu, 11:30am - 2pm
+    parking_ticket = expr1 | expr2
+    assert parking_ticket.include?(@datetime_200403111215), "Expression #{parking_ticket.to_s} should include #{@datetime_200403111215.to_s}"
+    assert parking_ticket.include?(@datetime_200403100915), "Expression #{parking_ticket.to_s} should include #{@datetime_200403100915.to_s}"
+    assert parking_ticket.include?(@datetime_200403100800), "Expression #{parking_ticket.to_s} should include #{@datetime_200403100800.to_s}"
+    assert !parking_ticket.include?(@datetime_200403110115), "Expression #{parking_ticket.to_s} should not include #{@datetime_200403110115.to_s}"
+
+    # The preceeding example can be condensed to:
+    #   e1 = (DIWeek.new(Mon) | DIWeek.new(Wed) | DIWeek.new(Fri)) & REDay.new(8,00,11,00)
+    #   e2 = (DIWeek.new(Tue) | DIWeek.new(Thu)) & REDay.new(11,30,14,00)
+    #   ticket = e1 | e2
+ end
+
+end

data/test/daterangetest.rb

@@ -0,0 +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

data/test/dayintervaltetest.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for DayIntervalTE class
+# Author:: Matthew Lipper
+
+class DayIntervalTETest < BaseExpressionTest
+
+
+  def test_every_8_days
+    date = @date_20040116
+    # Match every 8 days
+    expr = DayIntervalTE.new(date, 8)
+    assert expr.include?(date + 8), "Expression #{expr.to_s} should include #{(date + 8).to_s}"
+    assert expr.include?(date + 16), "Expression #{expr.to_s} should include #{(date + 16).to_s}"
+    assert expr.include?(date + 64), "Expression #{expr.to_s} should include #{(date + 64).to_s}"
+    assert !expr.include?(date + 4), "Expression #{expr.to_s} should not include #{(date + 4).to_s}"
+    # FIXME This test fails
+    #assert !expr.include?(date - 8), "Expression #{expr.to_s} should not include #{(date - 8).to_s}"
+  end
+
+  def test_every_2_days
+    date = @datetime_200709161007
+    expr = DayIntervalTE.new(date, 2)
+    assert expr.include?(date + 2), "Expression #{expr.to_s} should include #{(date + 2).to_s}"
+    assert expr.include?(date + 4), "Expression #{expr.to_s} should include #{(date + 4).to_s}"
+    assert !expr.include?(date + 3), "Expression #{expr.to_s} should not include #{(date + 3).to_s}"
+  end
+  
+  def test_to_s
+    every_four_days = DayIntervalTE.new(Date.new(2006,2,26), 4)
+    assert_equal "every 4th day after #{Runt.format_date(Date.new(2006,2,26))}", every_four_days.to_s
+  end
+
+  
+end

data/test/difftest.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for Diff class
+# Author:: Matthew Lipper
+
+class DiffTest < BaseExpressionTest
+
+  def setup
+    super
+    @diff = Diff.new(@stub1, @stub2)
+    @date = @pdate_20071008
+  end
+
+  def test_initialize
+    assert_same @stub1, @diff.expr1, "Expected #{@stub1} instance used to create expression. Instead got #{@diff.expr1}"
+    assert_same @stub2, @diff.expr2, "Expected #{@stub2} instance used to create expression. Instead got #{@diff.expr2}"
+  end
+
+  def test_to_s
+    assert_equal @stub1.to_s + ' except for ' + @stub2.to_s, @diff.to_s
+  end
+
+  def test_include
+    # Diff will match only if expr1 && !expr2
+    @stub1.match = false
+    @stub2.match = false
+    assert !@diff.include?(@date), "Diff instance should not include any dates"
+    @stub2.match = true
+    assert !@diff.include?(@date), "Diff instance should not include any dates"
+    @stub1.match = true
+    assert !@diff.include?(@date), "Diff instance should not include any dates"
+    @stub2.match = false
+    assert @diff.include?(@date), "Diff instance should include any dates"
+  end
+end

data/test/dimonthtest.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for DIMonth class
+# Author:: Matthew Lipper
+
+class DIMonthTest < BaseExpressionTest
+  def setup
+    super
+    @date_range = @date_20050101..@date_20051231
+  end
+
+  ###
+  # Dates functionality & tests contributed by Emmett Shear
+  ###
+  def test_dates_mixin_first_tuesday
+    dates = DIMonth.new(First, Tuesday).dates(@date_range)
+    assert dates.size == 12
+    dates.each do |d|
+      assert @date_range.include?(d)
+      assert d.wday == 2 # tuesday
+      assert d.day < 8 # in the first week
+    end
+  end
+
+  def test_dates_mixin_last_friday
+    dates = DIMonth.new(Last, Friday).dates(@date_range)
+    assert dates.size == 12
+    month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] 
+    dates.each do |d|
+      assert @date_range.include?(d)
+      assert d.wday == 5 # friday
+      assert d.day > month_days[d.month-1] - 8 # last week
+    end
+  end
+
+  def test_third_friday_of_the_month
+    expr = DIMonth.new(Third,Friday)
+    assert expr.include?(@date_20040116), "Third Friday of the month should include #{@date_20040116.to_s}"
+    assert !expr.include?(@date_20040109), "Third Friday of the month should not include #{@date_20040109.to_s}"
+  end
+
+  def test_second_friday_of_the_month
+    expr = DIMonth.new(Second,Friday)
+    assert expr.include?(@date_20040109), "Second Friday of the month should include #{@date_20040109.to_s}"
+    assert !expr.include?(@date_20040116), "Second Friday of the month should not include #{@date_20040116.to_s}"
+  end
+  
+  def test_last_sunday_of_the_month
+    expr = DIMonth.new(Last_of,Sunday)
+    assert expr.include?(@date_20040125), "Last Sunday of the month should include #{@date_20040125}"
+  end
+  
+  def test_to_s
+    assert_equal 'last Sunday of the month', DIMonth.new(Last_of,Sunday).to_s
+  end
+
+end

data/test/diweektest.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for DIWeek class
+# Author:: Matthew Lipper
+
+class DIWeekTest < BaseExpressionTest
+
+  def test_day_in_week_te
+    expr = DIWeek.new(Friday)
+    assert expr.include?(@date_20040109), "'Friday' should include #{@date_20040109} which is a Friday"
+    assert expr.include?(@date_20040116), "'Friday' should include #{@date_20040116} which is a Friday"
+    assert !expr.include?(@date_20040125), "'Friday' should not include #{@date_20040125} which is a Sunday"
+  end
+  
+  def test_day_in_week_te_to_s
+    assert_equal 'Friday', DIWeek.new(Friday).to_s
+  end
+
+  def test_day_in_week_dates
+    expr = DIWeek.new(Sunday)
+    dates = expr.dates(@date_20050101..@date_20050131)
+    assert dates.size == 5, "There are five Sundays in January, 2005: found #{dates.size}" 
+    assert dates.include?(@date_20050102), "Should include #{@date_20050102}"
+    assert dates.include?(@date_20050109), "Should include #{@date_20050109}"
+    assert dates.include?(@date_20050116), "Should include #{@date_20050116}"
+    assert dates.include?(@date_20050123), "Should include #{@date_20050123}"
+    assert dates.include?(@date_20050130), "Should include #{@date_20050130}"
+  end
+
+end

data/test/dprecisiontest.rb

@@ -0,0 +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::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