#!/usr/bin/ruby -I./lib/ -I../lib/


require 'custodian/util/timespan'
require 'test/unit'



#
# Unit test for our time-span code.
#
class TestTimeSpanUtil < Test::Unit::TestCase

  #
  # Create the test suite environment: NOP.
  #
  def setup
  end

  #
  # Destroy the test suite environment: NOP.
  #
  def teardown
  end

  #
  #  Test the expansion of "obvious" hour-specifiers.
  #
  def test_to_hour

    for hour in 0..23
      assert_equal(hour, Custodian::Util::TimeSpan.to_hour(hour))
    end

    #
    #  Invalid hours will throw exceptions
    #
    assert_raise ArgumentError do
      result = Custodian::Util::TimeSpan.to_hour(0.5)
    end
    assert_raise ArgumentError do
      result = Custodian::Util::TimeSpan.to_hour(-1)
    end
    assert_raise ArgumentError do
      result = Custodian::Util::TimeSpan.to_hour(100)
    end
    assert_raise ArgumentError do
      result = Custodian::Util::TimeSpan.to_hour(24)
    end
    assert_raise ArgumentError do
      result = Custodian::Util::TimeSpan.to_hour(25)
    end

    #
    #  Ensure AM times work well
    #
    for hour in 0..11
      assert_equal(hour, Custodian::Util::TimeSpan.to_hour("#{hour}am"))
    end

    for hour in 0..11
      assert_equal(12 + hour, Custodian::Util::TimeSpan.to_hour("#{hour}pm"))
    end

  end


  #
  #
  #  Ensure we received errors if the start/end hours are under/over 24
  #
  def test_excessive_hours

    #
    #  Valid hours are 0-23, inclusive.  Test outside that range.
    #
    for i in 24..100
      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?(i, 2)
      end

      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?(1, i)
      end

      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?(1, 2, i)
      end
    end

    #
    #  Now negative values.
    #
    for i in 1..50

      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?(1, (-1 * i))
      end

      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?((-1 * i), 1)
      end

      assert_raise ArgumentError do
        result = Custodian::Util::TimeSpan.inside?(1, 1, (-1 * i))
      end
    end

  end


  #
  #  Test simple cases where the period is positive.
  #
  def test_simple_cases
    # 8am-5pm
    assert(Custodian::Util::TimeSpan.inside?('8am', '5am', 12))
    assert(Custodian::Util::TimeSpan.inside?(8, 17, 12))

  end

  #
  #  Test cases which involve the wrap-around over midnight.
  #
  def test_midnight_cases

    # 9pm-2am
    assert(Custodian::Util::TimeSpan.inside?('9pm', '2am', 22))
    assert(Custodian::Util::TimeSpan.inside?('9pm', '2am', '10pm'))
    assert(Custodian::Util::TimeSpan.inside?(21, 2, 22))
    assert(Custodian::Util::TimeSpan.inside?(21, 2, '10pm'))

    # 10pm-3am
    assert(Custodian::Util::TimeSpan.inside?('10pm', '3am', 22))
    assert(Custodian::Util::TimeSpan.inside?(22, 3, 22))
    assert(Custodian::Util::TimeSpan.inside?(22, 3, 22))
    assert(Custodian::Util::TimeSpan.inside?(22, 3, '10pm'))

    # 11pm-5am
    assert(Custodian::Util::TimeSpan.inside?('11pm', '5am', 23))
    assert(Custodian::Util::TimeSpan.inside?(23, 5, 23))
    assert(Custodian::Util::TimeSpan.inside?('11pm', '5am', '11pm'))

    # midnight-3am
    assert(Custodian::Util::TimeSpan.inside?('0', '3am', 1))
    assert(Custodian::Util::TimeSpan.inside?('0', '3am', '1am'))
  end


  #
  #  The time-spans listed are inclusive.
  #
  #  Test the boundaries.
  #
  def test_inclusive

    open = '4pm'
    close = '6pm'

    # The hours + the middle should be inside
    assert(Custodian::Util::TimeSpan.inside?(open, close, 16))
    assert(Custodian::Util::TimeSpan.inside?(open, close, '4pm'))

    assert(Custodian::Util::TimeSpan.inside?(open, close, 17))
    assert(Custodian::Util::TimeSpan.inside?(open, close, '5pm'))

    assert(Custodian::Util::TimeSpan.inside?(open, close, 18))
    assert(Custodian::Util::TimeSpan.inside?(open, close, '6pm'))


    #
    # The preceeding + successive hours shouldn't be.
    #
    assert(!Custodian::Util::TimeSpan.inside?(open, close, 15))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, 19))

    #
    # That is true for the string-versions too
    #
    assert(!Custodian::Util::TimeSpan.inside?(open, close, '3pm'))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, '7pm'))


    #
    # Random hours should be outside too.
    #
    assert(!Custodian::Util::TimeSpan.inside?(open, close, 3))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, '3am'))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, 7))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, '7am'))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, 9))
    assert(!Custodian::Util::TimeSpan.inside?(open, close, '9am'))

  end


  #
  #  Since the implementation of our test involves
  # iterating over the specified period then any 24-hour
  # period is the worst case.
  #
  #
  def test_worst
    for i in 0..23
      assert(Custodian::Util::TimeSpan.inside?(0, 23, i))
    end
  end

  #
  #  Test that we don't wrap-around unexpectedly.
  #
  #
  #  i.e. "between 00-00" is one hour, not 24.
  #
  def test_wrap_around

    for h in 00..23
      assert_equal(1, Custodian::Util::TimeSpan.to_hours(h, h).size)
    end

    #
    #  But the time-period 00-23 is a full day
    #
    assert_equal(24,
                 Custodian::Util::TimeSpan.to_hours(0, 23).size)

  end


end