runt19 0.7.6

data/test/intersecttest.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for Intersect class
+# Author:: Matthew Lipper
+
+class IntersectTest < BaseExpressionTest
+
+  def setup
+    super
+    @intersect = Intersect.new
+    @date = @pdate_20071008
+  end
+
+  def test_to_s
+    assert_equal 'empty', @intersect.to_s
+    @intersect.add(@stub1)
+    assert_equal 'every ' + @stub1.to_s, @intersect.to_s
+    @intersect.add(@stub2)
+    assert_equal 'every ' + @stub1.to_s + ' and ' + @stub2.to_s, @intersect.to_s
+  end
+
+
+  def test_include
+    assert !@intersect.include?(@date), "Empty Intersect instance should not include any dates"
+    @intersect.add(@stub1).add(@stub2) # both expressions will return false
+    assert !@intersect.include?(@date), "Intersect instance should not include any dates"
+    @stub2.match = true
+    assert !@intersect.include?(@date), "Intersect instance should not include any dates"
+    @stub1.match = true
+    assert @intersect.include?(@date), "Intersect instance should include any dates"
+  end
+end

data/test/pdatetest.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'date'
+require 'runt'
+
+# Unit tests for PDate class
+# Author:: Matthew Lipper
+class PDateTest < Test::Unit::TestCase
+
+  include Runt
+
+  def setup
+    # 2010 (August - ignored)
+    @year_prec = PDate.year(2010,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)
+    #12:00:10 am, March 1st, 2004
+    @second_prec = PDate.sec(2004,3,1,0,0,10)
+  end
+
+  def test_marshal
+    # Thanks to Jodi Showers for finding/fixing this bug
+    pdate=PDate.new(2004,2,29,22,13,2)
+    assert_not_nil pdate.date_precision
+    data=Marshal.dump pdate
+    obj=Marshal.load data
+    assert_not_nil obj.date_precision
+  end
+
+  def test_include
+    pdate = PDate.new(2006,3,10)
+    assert(pdate.include?(Date.new(2006,3,10)))
+    date = Date.new(2006,3,10)
+    assert(date.include?(PDate.new(2006,3,10)))
+  end
+
+  def test_new
+    date = PDate.new(2004,2,29)
+    assert(!date.date_precision.nil?)
+    date_time = PDate.new(2004,2,29,22,13,2)
+    assert(!date_time.date_precision.nil?)
+    date2 = PDate.day(2004,2,29)
+    assert(date==date2)
+    date_time2 = PDate.sec(2004,2,29,22,13,2)
+    assert(date_time==date_time2)
+  end
+
+  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))
+  end
+
+  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))
+    assert(PDate.sec(2004,2,29,23,59,59)==(@second_prec-11))
+  end
+  def test_spaceship_comparison_operator
+    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)
+    assert(Date.new(2004,8,28)>sec_prec)
+  end
+  def test_succ
+    #~ fail("FIXME! Implement succ")
+  end
+  def test_range
+    #11:50 pm (:22 seconds ignored), February 2nd, 2004
+    min1 = PDate.min(2004,2,29,23,50,22)
+    #12:02 am , March 1st, 2004
+    min2 = PDate.min(2004,3,1,0,2)
+    #Inclusive Range w/minute precision
+    r_min = min1..min2
+    assert( r_min.include?(PDate.min(2004,2,29,23,50,22)) )
+    assert( r_min.include?(PDate.min(2004,3,1,0,2)) )
+    assert( r_min.include?(PDate.min(2004,3,1,0,0)) )
+    assert( ! r_min.include?(PDate.min(2004,3,1,0,3)) )
+    #Exclusive Range w/minute precision
+    r_min = min1...min2
+    assert( r_min.include?(PDate.min(2004,2,29,23,50,22)) )
+    assert( !r_min.include?(PDate.min(2004,3,1,0,2)) )
+  end
+
+  def test_create_with_class_methods
+    #December 12th, 1968
+    no_prec = PDate.civil(1968,12,12)
+    #December 12th, 1968 (at 11:15 am - ignored)
+    day_prec = PDate.day(1968,12,12,11,15)
+    assert(no_prec==day_prec, "PDate instance does not equal precisioned instance.")
+    #December 2004 (24th - ignored)
+    month_prec1 = PDate.month(2004,12,24)
+    #December 31st, 2004  (31st - ignored)
+    month_prec2 = PDate.month(2004,12,31)
+    assert(month_prec1==month_prec2, "PDate.month instances not equal.")
+    #December 2004
+    month_prec3 = PDate.month(2004,12)
+    assert(month_prec1==month_prec3, "PDate.month instances not equal.")
+    assert(month_prec2==month_prec3, "PDate.month instances not equal.")
+    #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

data/test/redaytest.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for REDay class
+# Author:: Matthew Lipper
+
+class REDayTest < BaseExpressionTest
+
+
+  def test_noon_to_430
+    #noon to 4:30pm
+    expr = REDay.new(12,0,16,30)
+    assert expr.include?(@pdate_2012050815), "Expression #{expr.to_s} should include #{@pdate_2012050815.to_s}"
+    assert expr.include?(@pdate_1922041816), "Expression #{expr.to_s} should include #{@pdate_1922041816.to_s}"
+    assert expr.include?(@pdate_1975060512), "Expression #{expr.to_s} should include #{@pdate_1975060512.to_s}"
+    assert !expr.include?(@pdate_2012050803), "Expression #{expr.to_s} should not include #{@pdate_2012050803.to_s}"
+  end
+  def test_830_to_midnight
+    expr = REDay.new(20,30,00,00)
+    assert expr.include?(@pdate_200401282100), "Expression #{expr.to_s} should include #{@pdate_200401282100.to_s}"
+    assert expr.include?(@pdate_200401280000), "Expression #{expr.to_s} should include #{@pdate_200401280000.to_s}"
+    assert !expr.include?(@pdate_200401280001), "Expression #{expr.to_s} should not include #{@pdate_200401280001.to_s}"
+  end
+
+  def test_range_each_day_te_to_s
+    assert_equal 'from 11:10PM to 01:20AM daily', REDay.new(23,10,1,20).to_s
+  end
+
+  def test_less_precise_argument_and_precision_policy
+    expr = REDay.new(8,00,10,00)
+    assert expr.include?(@pdate_20040531), \
+      "Expression #{expr.to_s} should include any lower precision argument by default"
+
+    expr = REDay.new(8,00,10,00, false)
+    assert !expr.include?(@pdate_20040531), \
+      "Expression #{expr.to_s} created with less_precise_match=false should not include any lower precision argument automatically"
+  end
+  
+end

data/test/remonthtest.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for REMonth class
+# Author:: Matthew Lipper
+
+class REMonthTest < BaseExpressionTest
+
+
+  def test_20th_thru_29th_of_every_month
+   expr = REMonth.new(20,29)
+   assert expr.include?(@date_20050123), "Expression #{expr.to_s} should include #{@date_20050123.to_s}" 
+   assert !expr.include?(@date_20050116), "Expression #{expr.to_s} should not include #{@date_20050116.to_s}"
+  end
+
+  def test_16th_of_every_month
+   expr = REMonth.new(16)
+   assert expr.include?(@date_20050116), "Expression #{expr.to_s} should include #{@date_20050116.to_s}"
+   assert !expr.include?(@date_20050123), "Expression #{expr.to_s} should not include #{@date_20050123.to_s}"
+  end
+  
+  def test_dates_mixin
+    expr = REMonth.new(22, 26)
+    dates = expr.dates(@pdate_20071024..@pdate_20071028)
+    assert dates.size == 3, "Expected 2 dates and got #{dates.size}"
+    # Use default Test::Unit assertion message
+    assert_equal "2007-10-24T00:00:00+00:00", dates[0].to_s
+    assert_equal "2007-10-25T00:00:00+00:00", dates[1].to_s
+    assert_equal "2007-10-26T00:00:00+00:00", dates[2].to_s
+  end
+  
+  def test_range_each_month_to_s
+    assert_equal 'from the 2nd to the 5th monthly',REMonth.new(2,5).to_s
+  end
+  
+end

data/test/reweektest.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for REWeek class
+# Author:: Matthew Lipper
+
+class REWeekTest < BaseExpressionTest
+
+
+  def test_invalid_ctor_arg
+    assert_raises(ArgumentError,"Expected ArgumentError for invalid day of week ordinal"){ REWeek.new(10,4) }
+  end
+
+  def test_monday_thru_friday
+    expr = REWeek.new(Mon,Fri)
+    assert expr.include?(@date_20040116), "Expression #{expr.to_s} should include #{@date_20040116.to_s}"
+    assert !expr.include?(@date_20040125), "Expression #{expr.to_s} should not include #{@date_20040125.to_s}"
+  end
+  
+  def test_friday_thru_tuesday
+    expr = REWeek.new(Fri,Tue)
+    assert expr.include?(@date_20040125), "Expression #{expr.to_s} should include #{@date_20040125.to_s}"
+    assert !expr.include?(@pdate_20071024), "Expression #{expr.to_s} should not include #{@pdate_20071024.to_s}"
+  end
+  
+  def test_range_each_week_te
+    #Friday through Tuesday
+     expr = REWeek.new(Friday,Tuesday) 
+     assert expr.include?(@time_20070928000000), "#{expr.inspect} should include Fri 12am"
+     assert expr.include?(@time_20070925115959), "#{expr.inspect} should include Tue 11:59pm"
+     assert !expr.include?(@time_20070926000000),"#{expr.inspect} should not include Wed 12am"
+     assert !expr.include?(@time_20070927065959),"#{expr.inspect} should not include Thurs 6:59am"
+     assert !expr.include?(@time_20070927115900),"#{expr.inspect} should not include Thurs 1159am"
+     assert expr.include?(@time_20070929110000), "#{expr.inspect} should include Sat 11am"
+     assert expr.include?(@time_20070929000000), "#{expr.inspect} should include Sat midnight"
+     assert expr.include?(@time_20070929235959), "#{expr.inspect} should include Saturday one minute before midnight"
+     assert expr.include?(@time_20070930235959), "#{expr.inspect} should include Sunday one minute before midnight"
+  end
+  
+  def test_to_s
+    assert_equal 'all week', REWeek.new(Tuesday,Tuesday).to_s
+    assert_equal 'Thursday through Saturday', REWeek.new(Thursday,Saturday).to_s
+  end
+
+  def test_dates_mixin
+    dates = REWeek.new(Tue,Wed).dates(@pdate_20071008..@pdate_20071030)
+    assert dates.size == 7
+  end
+  
+end

data/test/reyeartest.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for REYear class
+# Author:: Matthew Lipper
+
+class REYearTest < BaseExpressionTest
+
+  def test_ctor_one_arg
+    expr = REYear.new(11)
+    assert expr.start_month == 11, "Start month should equal 11"
+    assert expr.end_month == 11, "End month should equal 11"
+    assert expr.start_day == REYear::NO_DAY, "Start day should equal constant NO_DAY"
+    assert expr.end_day == REYear::NO_DAY, "End day should equal constant NO_DAY"
+  end
+  
+  def test_ctor_two_args
+    expr = REYear.new(11,12)
+    assert expr.start_month == 11, "Start month should equal 11"
+    assert expr.end_month == 12, "End month should equal 12"
+    assert expr.start_day == REYear::NO_DAY, "Start day should equal constant NO_DAY"
+    assert expr.end_day == REYear::NO_DAY, "End day should equal constant NO_DAY"
+  end
+
+  def test_ctor_three_args
+    expr = REYear.new(10,21,12)
+    assert expr.start_month == 10, "Start month should equal 10"
+    assert expr.end_month == 12, "End month should equal 12"
+    assert expr.start_day == 21, "Start day should equal 21"
+    assert expr.end_day == REYear::NO_DAY, "End day should equal constant NO_DAY"
+  end
+
+  def test_ctor_three_args
+    expr = REYear.new(10,21,12,3)
+    assert expr.start_month == 10, "Start month should equal 10"
+    assert expr.end_month == 12, "End month should equal 12"
+    assert expr.start_day == 21, "Start day should equal 21"
+    assert expr.end_day == 3, "End day should equal 3"
+  end
+
+  def test_specific_days_same_month
+    expr = REYear.new(10,20,10,29)
+    assert expr.include?(@pdate_20071028), "#{expr.to_s} should include #{@pdate_20071028}" 
+    assert !expr.include?(@pdate_20071114), "#{expr.to_s} should not include #{@pdate_20071114}" 
+    assert !expr.include?(@pdate_20071030), "#{expr.to_s} should not include #{@pdate_20071030}" 
+    assert !expr.include?(@pdate_20071008), "#{expr.to_s} should not include #{@pdate_20071008}" 
+    assert !expr.include?(@pdate_20060921), "#{expr.to_s} should not include #{@pdate_20060921}"
+  end
+
+  def test_specific_days_different_months
+    expr = REYear.new(5,31,9,6)
+    assert expr.include?(@pdate_198606), "#{expr.to_s} should include #{@pdate_198606}" 
+    assert expr.include?(@date_20040806), "#{expr.to_s} should include #{@date_20040806}" 
+    assert !expr.include?(@pdate_20071008), "#{expr.to_s} should not include #{@pdate_20071008}"  
+  end
+
+  def test_default_days_different_months
+    expr = REYear.new(11,12)
+    assert expr.include?(@date_19611101), "#{expr.to_s} should include #{@date_19611101}"
+    assert !expr.include?(@pdate_198606), "#{expr.to_s} should not include #{@pdate_198606}" 
+  end
+
+  def test_all_defaults
+    expr = REYear.new(8)
+    assert expr.include?(@date_20040806), "#{expr.to_s} should include #{@date_20040806}" 
+    assert !expr.include?(@pdate_198606), "#{expr.to_s} should not include #{@pdate_198606}" 
+    assert !expr.include?(@date_19611101), "#{expr.to_s} should not include #{@date_19611101}"
+  end
+  
+  def test_same_days_same_month
+    # Bug #5741
+    expr = REYear.new(9,21,9,21)
+    assert expr.include?(@pdate_20060921), "#{expr.to_s} should include #{@pdate_20060921.to_s}" 
+    assert !expr.include?(@pdate_20060914), "#{expr.to_s} should not include #{@pdate_20060914.to_s}"
+  end
+
+  def test_to_s
+    assert_equal 'June 1st through July 2nd', REYear.new(6, 1, 7, 2).to_s
+  end
+  
+  def test_dates_mixin
+    expr = REYear.new(4, 28, 5, 6)
+    assert((expr.dates(@date_20040501..@date_20060504)).size == 22, "Should be 22 occurences in dates Array")
+  end
+
+  # From bug #5749 
+  def test_mixed_precision_combo
+    # 10:00 am to 10:01 am
+    ten_ish = REDay.new(10,0,10,1)
+    # September 21st every year
+    every_21_sept = REYear.new(9,21,9,21)
+    # Between 10:00 am and 10:01 am every September 21st
+    combo = ten_ish & every_21_sept
+    assert combo.include?(@pdate_20060921), "Should include lower precision argument"
+    assert combo.include?(@pdate_200609211001), "Should include matching precision argument which is in range"
+    assert !combo.include?(@pdate_200609211002), "Should not include matching precision argument which is out of range"
+  end
+end

data/test/rspectest.rb

@@ -0,0 +1,25 @@
+
+#!/usr/bin/env ruby
+
+require 'baseexpressiontest'
+
+# Unit tests for RSpec class
+# Author:: Matthew Lipper
+
+class RSpecTest < BaseExpressionTest
+
+  def test_include
+    rspec = RSpec.new(@stub1)
+    assert !rspec.include?("Any Object"), "Expression should not include any given argument"
+    @stub1.match = true
+    assert rspec.include?("Any Object"), "Expression should include any given argument"
+  end
+  
+  def test_overlap
+    range = DateRange.new(@date_20050101, @date_20050109)
+    rspec = RSpec.new(range)
+    assert !rspec.include?(@date_20050116), "Expression #{rspec.to_s} should not include #{@date_20050116.to_s}"
+    assert rspec.include?(@date_20050102), "Expression #{rspec.to_s} should include #{@date_20050102.to_s}"
+  end
+  
+end

data/test/runttest.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'runt'
+require 'date'
+require 'pp'
+
+class RuntModuleTest < Test::Unit::TestCase
+  
+  def test_last
+    assert Runt::Last == -1
+  end
+  
+  def test_last_of
+    assert Runt::Last_of == -1
+  end
+
+  def test_second_to_last
+    assert Runt::Second_to_last == -2
+  end
+
+  def test_ordinals
+    #1.upto(31){ |n| puts Runt.ordinalize(n); }
+    assert_equal '1st', Runt.ordinalize(1)
+    assert_equal '33rd', Runt.ordinalize(33)
+    assert_equal '50th', Runt.ordinalize(50)
+    assert_equal '2nd', Runt.ordinalize(2)
+    assert_equal 'second to last', Runt.ordinalize(-2)
+    assert_equal 'last', Runt.ordinalize(-1)
+  end
+
+  def test_day_name
+    i=0
+    Date::DAYNAMES.each do |n|
+      assert_equal Date::DAYNAMES[i], Runt.day_name(i)
+      i=i+1
+    end
+  end
+  
+  def test_month_name
+    i=0
+    Date::MONTHNAMES.each do |n|
+      assert_equal Date::MONTHNAMES[i], Runt.month_name(i)
+      i=i+1
+    end
+  end
+
+  def test_strftime
+    d=DateTime.new(2006,2,26,14,45)
+    assert_equal '02:45PM', Runt.format_time(d)
+  end
+
+  def test_numeric_class_additions
+    assert_equal 0.000001, 1.microsecond
+    assert_equal 0.000001, 1.microseconds
+    assert_equal 0.001, 1.millisecond
+    assert_equal 0.001, 1.milliseconds
+    assert_equal 7, 7.second
+    assert_equal 7, 7.seconds
+    assert_equal 60, 1.minute
+    assert_equal 60, 1.minutes
+    assert_equal 3600, 1.hour
+    assert_equal 3600, 1.hours
+    assert_equal 86400, 1.day
+    assert_equal 86400, 1.days
+    assert_equal 604800, 1.week
+    assert_equal 604800, 1.weeks
+    assert_equal 2592000, 1.month
+    assert_equal 2592000, 1.months
+    assert_equal 31536000, 1.year
+    assert_equal 31536000, 1.years
+    assert_equal 315360000, 1.decade
+    assert_equal 315360000, 1.decades
+  end
+
+  def test_time_class_dprecision
+    time=Time.parse('Monday 06 November 2006 07:38')
+    assert_equal(Runt::DPrecision::DEFAULT,time.date_precision)
+  end
+
+  def test_date_class_dprecision
+    date=Date.today
+    assert_equal(Runt::DPrecision::DEFAULT,date.date_precision)
+  end
+
+  def test_datetime_class_dprecision
+    date=DateTime.civil
+    assert_equal(Runt::DPrecision::DEFAULT,date.date_precision)
+  end
+
+  def test_time_plus
+    time=Time.local(2006, 12, 9, 5, 56, 12)
+    # Default precision is minute
+    assert_equal(Runt::PDate.min(2006,12,9,5,56),Runt::DPrecision.to_p(time))
+    assert_not_equal(Time.parse("Sat Dec 09 05:56:00 -0500 2006"),time)
+  end
+
+end