fsevent 0.1

data/test/test_framework.rb

@@ -0,0 +1,167 @@
+# test_framework.rb --- test for framework.rb
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+require 'fsevent'
+
+class TestFSEventFramework < Test::Unit::TestCase
+
+  class TDevice < FSEvent::AbstractDevice
+    attr_accessor :test_result
+    def initialize(device_name)
+      super
+      @test_result = []
+    end
+  end
+
+  def test_nodevice
+    fsevent = FSEvent.new
+    assert_nothing_raised { fsevent.start }
+  end
+
+  def test_inactive_device
+    fsevent = FSEvent.new
+    device = FSEvent::AbstractDevice.new("test_inactive_device")
+    assert_nothing_raised { fsevent.start }
+  end
+
+  def test_single_run
+    t0 = Time.utc(2000)
+    t1 = Time.utc(2001)
+    fsevent = FSEvent.new(t0)
+    device = TDevice.new("test_single_run")
+    device.schedule.merge_schedule([t1])
+    def device.run(watched_status_change)
+      @test_result << @framework.current_time
+      @test_result << watched_status_change
+    end
+    fsevent.register_device(device)
+    assert_nothing_raised { fsevent.start }
+    assert_equal([t1, nil], device.test_result)
+  end
+
+  def test_double_run
+    t0 = Time.utc(2000)
+    t1 = Time.utc(2001)
+    t2 = Time.utc(2002)
+    fsevent = FSEvent.new(t0)
+    device = TDevice.new("test_double_run")
+    device.schedule.merge_schedule([t1, t2])
+    def device.run(watched_status_change)
+      @test_result << @framework.current_time
+      @test_result << watched_status_change
+    end
+    fsevent.register_device(device)
+    assert_nothing_raised { fsevent.start }
+    assert_equal([t1, nil, t2, nil], device.test_result)
+  end
+
+  def test_repeated_run
+    t0 = Time.utc(2000)
+    t1 = Time.utc(2001)
+    fsevent = FSEvent.new(t0)
+    device = TDevice.new("test_repeated_run")
+    schedule = FSEvent::PeriodicSchedule.new(t1, 3)
+    device.schedule.merge_schedule(schedule)
+    def device.run(watched_status_change)
+      @test_result << @framework.current_time
+      @schedule = [] if 2 < @test_result.length
+    end
+    fsevent.register_device(device)
+    assert_nothing_raised { fsevent.start }
+    assert_equal([t1, t1+3, t1+6], device.test_result)
+  end
+
+  def test_twodevice
+    t0 = Time.utc(2000)
+    t1 = Time.utc(2001)
+    t2 = Time.utc(2002)
+    fsevent = FSEvent.new(t0)
+    device1 = TDevice.new("test_twodevice_1")
+    device1.schedule.merge_schedule([t1])
+    def device1.run(watched_status_change)
+      @test_result << @framework.current_time
+    end
+    device2 = TDevice.new("test_twodevice_2")
+    device2.schedule.merge_schedule([t2])
+    def device2.run(watched_status_change)
+      @test_result << @framework.current_time
+    end
+    fsevent.register_device(device1)
+    fsevent.register_device(device2)
+    assert_nothing_raised { fsevent.start }
+    assert_equal([t1], device1.test_result)
+    assert_equal([t2], device2.test_result)
+  end
+
+  def test_unregister_in_sleeping
+    t0 = Time.utc(2000)
+    fsevent = FSEvent.new(t0)
+    sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
+    result = []
+    device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
+      |watched_status_change|
+      result << fsevent.current_time
+      fsevent.set_elapsed_time(2)
+    }
+    device2 = FSEvent::SimpleDevice.new("dev", {}, [], 1, [t0+23]) {
+      fsevent.unregister_device("target")
+    }
+    fsevent.register_device device1
+    fsevent.register_device device2
+    fsevent.start
+    assert_equal([t0+10,t0+15,t0+20], result)
+  end
+
+  def test_unregister_in_working
+    t0 = Time.utc(2000)
+    fsevent = FSEvent.new(t0)
+    sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
+    result = []
+    device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
+      |watched_status_change|
+      result << fsevent.current_time
+      fsevent.set_elapsed_time(2)
+    }
+    device2 = FSEvent::SimpleDevice.new("dev", {}, [], 1, [t0+21]) {
+      fsevent.unregister_device("target")
+    }
+    fsevent.register_device device1
+    fsevent.register_device device2
+    fsevent.start
+    assert_equal([t0+10,t0+15,t0+20], result)
+  end
+
+  def test_unregister_self
+    t0 = Time.utc(2000)
+    fsevent = FSEvent.new(t0)
+    sched1 = FSEvent::PeriodicSchedule.new(t0+10,5)
+    result = []
+    device1 = FSEvent::SimpleDevice.new("target", {}, [], 1, sched1) {
+      |watched_status_change|
+      result << fsevent.current_time
+      if fsevent.current_time == t0+20
+        fsevent.unregister_device("target")
+      end
+      fsevent.set_elapsed_time(2)
+    }
+    fsevent.register_device device1
+    fsevent.start
+    assert_equal([t0+10,t0+15,t0+20], result)
+  end
+
+end

data/test/test_processdevice.rb

@@ -0,0 +1,76 @@
+# test_processdevice.rb --- tests for processdevice.rb
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+require 'fsevent'
+
+class TestFSEventProcessDevice < Test::Unit::TestCase
+  def test_empty_definition_and_finish
+    d = FSEvent::ProcessDevice.spawner("").new("dname")
+    assert_kind_of(FSEvent::ProcessDevice, d)
+    assert_equal(nil, d.finish)
+  end
+
+  def test_name_call
+    d = FSEvent::ProcessDevice.spawner("").new("dname")
+    assert_equal("dname", d.call_subprocess(:name))
+  ensure
+    d.finish
+  end
+
+  def test_eval
+    d = FSEvent::ProcessDevice.spawner(<<-'End').new("dname")
+      def test_eval(str) eval(str) end
+    End
+    assert_equal("foo", d.call_subprocess(:test_eval, '"foo"'))
+  ensure
+    d.finish
+  end
+
+  def test_upcall_simple
+    framework = "123456"
+    d = FSEvent::ProcessDevice.spawner(<<-'End').new("dname")
+      def test_eval(str) eval(str) end
+    End
+    d.framework = framework
+    d.registered
+    assert_equal(123456,
+                 d.call_subprocess(:test_eval, 'call_parent(:to_i)'))
+  ensure
+    d.finish
+  end
+
+  def test_upcall_add_watch
+    framework = Object.new
+    def framework.add_watch(watchee_device_name, status_name)
+      @ary ||= []
+      @ary << watchee_device_name
+      @ary << status_name
+      nil
+    end
+    d = FSEvent::ProcessDevice.spawner(<<-'End').new("dname")
+      def test_eval(str) eval(str) end
+    End
+    d.framework = framework
+    d.registered
+    d.call_subprocess(:test_eval, '@framework.add_watch(1,2)')
+    assert_equal([1,2], framework.instance_variable_get(:@ary))
+  ensure
+    d.finish
+  end
+
+end

data/test/test_util.rb

@@ -0,0 +1,53 @@
+# test_util.rb --- tests for util.rb
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+require 'fsevent'
+
+class TestFSEventUtil < Test::Unit::TestCase
+  def test_nested_hash_level1
+    h = FSEvent::Util.nested_hash(1)
+    assert_equal(0, h.size)
+    assert_equal(nil, h[:k])
+    assert_equal(0, h.size)
+  end
+
+  def test_nested_hash_level2
+    h = FSEvent::Util.nested_hash(2)
+    assert_equal(0, h.size)
+    h2 = h[:k1]
+    assert_equal({}, h2)
+    assert_same(h2, h[:k1])
+    assert_equal(1, h.size)
+    assert_equal(nil, h[:k1][:k2])
+    assert_equal(0, h2.size)
+  end
+
+  def test_nested_hash_level3
+    h = FSEvent::Util.nested_hash(3)
+    assert_equal(0, h.size)
+    h2 = h[:k1]
+    assert_equal({}, h2)
+    assert_same(h2, h[:k1])
+    assert_equal(1, h.size)
+    h3 = h[:k1][:k2]
+    assert_equal({}, h3)
+    assert_same(h3, h[:k1][:k2])
+    assert_equal(1, h2.size)
+  end
+
+end

data/test/test_watch.rb

@@ -0,0 +1,169 @@
+# test_watch.rb --- tests for watching device status
+#
+# Copyright (C) 2014  National Institute of Advanced Industrial Science and Technology (AIST)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'test/unit'
+require 'fsevent'
+
+class TestFSEventWatch < Test::Unit::TestCase
+  def test_srcdevice
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    values = [9,2,3,5,1]
+    src_sched = values.map.with_index {|v, i| t + (i+1)*10 }
+    srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, src_sched) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(5)
+      fsevent.status_changed "s", values.shift
+    }
+    fsevent.register_device(srcdevice)
+    fsevent.start
+    assert_equal([], values)
+  end
+
+  def test_watch_register_order
+    2.times {|i|
+      t = Time.utc(2000)
+      fsevent = FSEvent.new(t)
+      values = [9,2,3,5,1]
+      src_sched = values.map.with_index {|v, i| t + (i+1)*10 }
+      srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, src_sched) {
+        |watched_status_change|
+        fsevent.set_elapsed_time(5)
+        fsevent.status_changed "s", values.shift
+      }
+      test_result = []
+      dstdevice = FSEvent::SimpleDevice.new("dst", {}, [["src","s"]], 1) {
+        |watched_status_change|
+        fsevent.set_elapsed_time(1)
+        test_result << [fsevent.current_time, watched_status_change]
+      }
+      if i == 0
+        fsevent.register_device(srcdevice)
+        fsevent.register_device(dstdevice)
+      else
+        fsevent.register_device(dstdevice)
+        fsevent.register_device(srcdevice)
+      end
+      fsevent.start
+      assert_equal(
+        [[t + 1,      {"src"=>{"s"=>0}}],
+         [t + 10*1+5, {"src"=>{"s"=>9}}],
+         [t + 10*2+5, {"src"=>{"s"=>2}}],
+         [t + 10*3+5, {"src"=>{"s"=>3}}],
+         [t + 10*4+5, {"src"=>{"s"=>5}}],
+         [t + 10*5+5, {"src"=>{"s"=>1}}]],
+        test_result)
+    }
+  end
+
+  def test_wakeup_immediate
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, [t+10]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(5)
+      fsevent.status_changed "s", 100
+    }
+    test_result = []
+    dstdevice = FSEvent::SimpleDevice.new("dst", {}, [["src","s", :immediate]], 1, [t+20]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(1)
+      test_result << [fsevent.current_time, watched_status_change]
+    }
+    fsevent.register_device(srcdevice)
+    fsevent.register_device(dstdevice)
+    fsevent.start
+    assert_equal(
+      [[t + 1, {"src"=>{"s"=>0}}],
+       [t + 15, {"src"=>{"s"=>100}}]],
+      test_result)
+  end
+
+  def test_wakeup_immediate_only_at_beginning
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, [t+10]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(5)
+      fsevent.status_changed "s", 100
+    }
+    test_result = []
+    dstdevice = FSEvent::SimpleDevice.new("dst", {}, [["src","s", :immediate_only_at_beginning]], 1, [t+20]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(1)
+      test_result << [fsevent.current_time, watched_status_change]
+    }
+    fsevent.register_device(srcdevice)
+    fsevent.register_device(dstdevice)
+    fsevent.start
+    assert_equal(
+      [[t + 1, {"src"=>{"s"=>0}}],
+       [t + 20, {"src"=>{"s"=>100}}]],
+      test_result)
+  end
+
+  def test_wakeup_schedule
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, [t+10]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(5)
+      fsevent.status_changed "s", 100
+    }
+    test_result = []
+    dstdevice = FSEvent::SimpleDevice.new("dst", {}, [["src","s", :schedule]], 1, [t+20]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(1)
+      test_result << [fsevent.current_time, watched_status_change]
+    }
+    fsevent.register_device(srcdevice)
+    fsevent.register_device(dstdevice)
+    fsevent.start
+    assert_equal(
+      [[t + 20, {"src"=>{"s"=>100}}]],
+      test_result)
+  end
+
+  def test_unwatch
+    t = Time.utc(2000)
+    fsevent = FSEvent.new(t)
+    s = 0
+    srcdevice = FSEvent::SimpleDevice.new("src", {"s"=>0}, [], 1, [t+10, t+20]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(5)
+      s += 100
+      fsevent.status_changed "s", s
+    }
+    test_result = []
+    dstdevice = FSEvent::SimpleDevice.new("dst", {}, [["src","s", :schedule]], 1, [t+17, t+27]) {
+      |watched_status_change|
+      fsevent.set_elapsed_time(1)
+      if fsevent.current_time == t+17
+        fsevent.del_watch("src", "s")
+      end
+      test_result << [fsevent.current_time, watched_status_change]
+    }
+    fsevent.register_device(srcdevice)
+    fsevent.register_device(dstdevice)
+    fsevent.start
+    assert_equal(
+      [[t+17, {"src"=>{"s"=>100}}],
+       [t+27, nil]],
+      test_result)
+  end
+
+end