scriptty 0.5.0-java

data/test/fsm_test.rb

@@ -0,0 +1,322 @@
+# = Tests for ScripTTY::Util::FSM
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require File.dirname(__FILE__) + "/test_helper.rb"
+require 'scriptty/util/fsm'
+
+class FSMTest < Test::Unit::TestCase
+
+  # Test the basic operation of the FSM.
+  def test_simple
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF)
+      'a' => eh
+      'x' => {
+        'y' => ex_why
+      }
+    EOF
+
+    fsm.process("a")
+    assert_equal 'a', fsm.input
+    assert_equal ['a'], fsm.input_sequence
+
+    fsm.process("x")
+    assert_equal 'x', fsm.input
+    assert_equal ['x'], fsm.input_sequence
+
+    fsm.process("y")
+    assert_equal 'y', fsm.input
+    assert_equal ['x', 'y'], fsm.input_sequence
+  end
+
+  def test_other
+    result = []
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF) { |event, fsm| result << event }
+      'a' => eh
+      'x' => {
+        'y' => ex_why
+        * => ex_other
+      }
+    EOF
+
+    fsm.process("a")
+    assert_equal 'a', fsm.input
+    assert_equal ['a'], fsm.input_sequence
+
+    fsm.process("x")
+    assert_equal 'x', fsm.input
+    assert_equal ['x'], fsm.input_sequence
+
+    assert_nothing_raised do
+      fsm.process("z")
+    end
+    assert_equal 'z', fsm.input
+    assert_equal ['x', 'z'], fsm.input_sequence
+    assert_equal [:eh, :ex_other], result
+  end
+
+  def test_empty_state
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF)
+      'x' => {
+      }
+    EOF
+    fsm.process("x")
+    assert_raise ScripTTY::Util::FSM::NoMatch do
+      fsm.process("y")
+    end
+  end
+
+  # The FSM should accept more than just single characters as inputs.
+  def test_string_inputs
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF)
+      "inputs" => {
+        "need not" => {
+          "be" => {
+            "single characters" => dummy
+          }
+        }
+      }
+    EOF
+
+    # The FSM should treat inputs as discrete units, not try to split them up
+    # into separate characters.
+    assert_raise ScripTTY::Util::FSM::NoMatch do
+      fsm.process("i")
+    end
+
+    # Test with longer words
+    fsm.process("inputs")
+    fsm.process("need not")
+    fsm.process("be")
+    fsm.process("single characters")
+    assert_equal ["inputs", "need not", "be", "single characters"], fsm.input_sequence
+  end
+
+  # Test that the FSM accepts a callback passed as a block to the constructor.
+  def test_callback_given_as_block
+    result = []
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF) { |event, fsm| result << [event, fsm.input_sequence] }
+      'a' => eh
+      'x' => {
+        'y' => ex_why
+      }
+    EOF
+    fsm.process('a')
+    assert_equal [[:eh, ['a']]], result
+
+    fsm.process('x')
+    assert_equal [[:eh, ['a']]], result
+
+    fsm.process('y')
+    assert_equal [[:eh, ['a']], [:ex_why, ['x', 'y']]], result
+  end
+
+  # Test that the FSM accepts a callback passed as an option to the constructor.
+  def test_callback_given_as_option
+    result = []
+    callback_proc = Proc.new { |event, fsm| result << [event, fsm.input_sequence] }
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF, :callback => callback_proc)
+      'a' => eh
+      'x' => {
+        'y' => ex_why
+      }
+    EOF
+    fsm.process('a')
+    assert_equal [[:eh, ['a']]], result
+
+    fsm.process('x')
+    assert_equal [[:eh, ['a']]], result
+
+    fsm.process('y')
+    assert_equal [[:eh, ['a']], [:ex_why, ['x', 'y']]], result
+  end
+
+  def test_intermediate_callback_with_redirect_proc
+    callback_class = Class.new do
+      attr_accessor :result
+      def csi(f)
+        f.redirect = lambda {|m| m.input =~ /[\d;]/}
+      end
+      def sgr(f)
+        @result ||= []
+        @result << f.input_sequence
+      end
+      def five(f)
+        @result ||= []
+        @result << :five
+      end
+    end
+    cb = callback_class.new
+    fsm = ScripTTY::Util::FSM.new(:callback => cb, :callback_method => :send, :definition => <<-EOF)
+      '\e' => {
+        '[' => csi => {
+          'm' => sgr
+        }
+      }
+      '5' => five
+    EOF
+    "\e[33;42m".split("").each {|c| fsm.process(c)}
+    fsm.process("5")
+    assert_equal [["\e", "[", "3", "3", ";", "4", "2", "m"], :five], cb.result
+  end
+
+  # Regression test:  If fsm.redirect was used with :next_state => 1,
+  # fsm.input_sequence would only contain the current input, rather than
+  # the whole sequence.  This tests the fix.
+  def test_final_callback_with_redirect
+    callback_class = Class.new do
+      attr_accessor :result
+      def handle_a(f)
+        f.redirect = :redirected
+      end
+      def redirected(f)
+        case f.input_sequence
+        when ['a', 'p', 'p', 'l', 'e']
+          f.redirect = nil
+          apple(f)
+        when ['a', 'c', 'r', 'o', 'b', 'a', 't']
+          f.redirect = nil
+          acrobat(f)
+        end
+        true
+      end
+      def apple(f)
+        @result ||= []
+        @result << :apple
+      end
+      def acrobat(f)
+        @result ||= []
+        @result << :acrobat
+      end
+    end
+    cb = callback_class.new
+    fsm = ScripTTY::Util::FSM.new(:callback => cb, :callback_method => :send, :definition => <<-EOF)
+      'a' => handle_a
+    EOF
+    "apple".split("").each {|c| fsm.process(c)}
+    "acrobat".split("").each {|c| fsm.process(c)}
+    assert_equal [:apple, :acrobat], cb.result
+  end
+
+  def test_intermediate_callback_with_redirect_symbol
+    callback_class = Class.new do
+      attr_accessor :result
+      def csi(f)
+        f.redirect = :csi_redirect
+      end
+      def csi_redirect(f)
+        f.input =~ /[\d;]/
+      end
+      def sgr(f)
+        @result ||= []
+        @result << f.input_sequence
+      end
+      def five(f)
+        @result ||= []
+        @result << :five
+      end
+    end
+    cb = callback_class.new
+    fsm = ScripTTY::Util::FSM.new(:callback => cb, :callback_method => :send, :definition => <<-EOF)
+      '\e' => {
+        '[' => csi => {
+          'm' => sgr
+        }
+      }
+      '5' => five
+    EOF
+    "\e[33;42m".split("").each {|c| fsm.process(c)}
+    fsm.process("5")
+    assert_equal [["\e", "[", "3", "3", ";", "4", "2", "m"], :five], cb.result
+  end
+
+  def test_reset
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF)
+      'a' => {
+        'b' => ab
+      }
+    EOF
+    assert_equal 1, fsm.next_state
+    assert fsm.initial_state?
+
+    fsm.process("a")
+    assert_not_equal 1, fsm.next_state
+    assert fsm.initial_state?
+
+    fsm.reset!
+    assert_equal 1, fsm.next_state
+    assert fsm.initial_state?
+
+    assert_raise ScripTTY::Util::FSM::NoMatch do
+      fsm.process("b")
+    end
+  end
+
+  def test_reset_during_callback
+    callback_class = Class.new do
+      attr_accessor :result
+      def redirect_true(f)
+        @result ||= [] ; @result << :redirect_true
+        f.reset!
+        true
+      end
+      def redirect_false(f)
+        @result ||= [] ; @result << :redirect_false
+        f.reset!
+        false
+      end
+      def x(f)
+        @result ||= [] ; @result << :x
+      end
+    end
+    cb = callback_class.new
+    fsm = ScripTTY::Util::FSM.new(:callback => cb, :callback_method => :send, :definition => <<-EOF)
+      'x' => x
+    EOF
+    assert_equal 1, fsm.next_state
+
+    cb.result = []
+    fsm.redirect = :redirect_true
+    fsm.process("x")
+    assert_equal [:redirect_true], cb.result
+    assert_equal 1, fsm.next_state
+    assert_nil fsm.redirect
+
+    cb.result = []
+    fsm.redirect = :redirect_false
+    fsm.process("x")
+    assert_equal [:redirect_false, :x], cb.result
+    assert_equal 1, fsm.next_state
+    assert_nil fsm.redirect
+  end
+
+  # Test the FSM#fire_event method
+  def test_fire_event
+    result = []
+    fsm = ScripTTY::Util::FSM.new(:definition => <<-EOF) { |event, fsm| result << event; fsm.fire_event(:xy) if event == :ex_why }
+      'a' => eh
+      'x' => {
+        'y' => ex_why
+      }
+    EOF
+
+    fsm.process("a")
+    fsm.process("x")
+    fsm.process("y")
+    assert_equal [:eh, :ex_why, :xy], result
+  end
+end

data/test/multiline_buffer_test.rb

@@ -0,0 +1,275 @@
+# = Tests for ScripTTY::MultilineBuffer
+# Copyright (C) 2010  Infonium Inc.
+#
+# This file is part of ScripTTY.
+#
+# ScripTTY is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ScripTTY 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ScripTTY.  If not, see <http://www.gnu.org/licenses/>.
+
+require File.dirname(__FILE__) + "/test_helper.rb"
+require 'scriptty/multiline_buffer'
+
+class MultilineBufferTest < Test::Unit::TestCase
+  def test_width_height
+    b = ScripTTY::MultilineBuffer.new(24,80)
+    assert_equal 24, b.height, "height should be 24 columns"
+    assert_equal 80, b.width, "width should be 80 columns"
+  end
+
+  def test_starts_blank
+    b = ScripTTY::MultilineBuffer.new(5,10)
+    expected = [
+      " "*10,
+      " "*10,
+      " "*10,
+      " "*10,
+      " "*10,
+    ]
+    assert_equal expected, b.content
+  end
+
+  def test_get_replace
+    b = ScripTTY::MultilineBuffer.new(5,10)
+    # Set up the buffer
+    assert_equal " "*10, b.replace_at(0, 0, "0123456789")
+    assert_equal " "*10, b.replace_at(1, 0, "ABCDEFGHIJ")
+    assert_equal " "*10, b.replace_at(2, 0, "KLMNOPQRST")
+    assert_equal " "*10, b.replace_at(3, 0, "UVWXYZabcd")
+    assert_equal " "*10, b.replace_at(4, 0, "efghijklmn")
+
+    # Test get_at
+    assert_equal "l", b.get_at(4,7), "default limit should be 1"
+    assert_equal "NOPQ", b.get_at(2,3,4), "basic get_at"
+    assert_equal "lmn", b.get_at(4,7,100), "overflowing length should be truncated"
+    assert_equal "lmn", b.get_at(4,7,-1), "negative limit"
+  end
+
+  def test_replace_at_array
+    b = ScripTTY::MultilineBuffer.new(5,10)
+    assert_equal [" "*10]*5, b.replace_at(0, 0, [
+      "0123456789",
+      "ABCDEFGHIJ",
+      "KLMNOPQRST",
+      "UVWXYZabcd",
+      "efghijklmn",
+    ])
+  end
+
+  def test_clear
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "          ",
+                "          ",
+                "          ",
+                "          ",
+                "          " ]
+
+    screen_modify_test(before, after) do |b|
+      b.clear!
+    end
+  end
+
+  def test_scroll_up_region_enclosed_1
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bbcccccbbb",
+                "ccdddddccc",
+                "dd     ddd",
+                "eeeeeeeeee" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_up_region( 1,2, 3,6, 1)
+    end
+  end
+
+  def test_scroll_up_region_enclosed_2
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bbdddddbbb",
+                "cc     ccc",
+                "dd     ddd",
+                "eeeeeeeeee" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_up_region( 1,2, 3,6, 2)
+    end
+  end
+
+  def test_scroll_down_region_enclosed_1
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bb     bbb",
+                "ccbbbbbccc",
+                "ddcccccddd",
+                "eeeeeeeeee" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_down_region( 1,2, 3,6, 1)
+    end
+  end
+
+  def test_scroll_down_region_enclosed_2
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bb     bbb",
+                "cc     ccc",
+                "ddbbbbbddd",
+                "eeeeeeeeee" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_down_region( 1,2, 3,6, 2)
+    end
+  end
+
+  def test_scroll_left_region_enclosed_1
+    before =  [ "0123456789",
+                "ABCDEFGHIJ",
+                "KLMNOPQRST",
+                "UVWXYZabcd",
+                "efghjijklm" ]
+
+    after =   [ "0123456789",
+                "ABDEFG HIJ",
+                "KLNOPQ RST",
+                "UVXYZa bcd",
+                "efghjijklm" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_left_region( 1,2, 3,6, 1)
+    end
+  end
+
+  def test_scroll_left_region_enclosed_3
+    before =  [ "0123456789",
+                "ABCDEFGHIJ",
+                "KLMNOPQRST",
+                "UVWXYZabcd",
+                "efghjijklm" ]
+
+    after =   [ "0123456789",
+                "ABFG   HIJ",
+                "KLPQ   RST",
+                "UVZa   bcd",
+                "efghjijklm" ]
+
+    screen_modify_test(before, after) do |b|
+      b.scroll_left_region( 1,2, 3,6, 3)
+    end
+  end
+
+  def test_scroll_left_down_up_right_region_enclosed_zero
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+    screen_modify_test(before, after, "scroll_left_region count=0") do |b|
+      b.scroll_left_region( 1,2, 3,6, 0)
+    end
+    screen_modify_test(before, after, "scroll_down_region count=0") do |b|
+      b.scroll_down_region( 1,2, 3,6, 0)
+    end
+    screen_modify_test(before, after, "scroll_up_region count=0") do |b|
+      b.scroll_up_region( 1,2, 3,6, 0)
+    end
+    screen_modify_test(before, after, "scroll_right_region count=0") do |b|
+      b.scroll_right_region( 1,2, 3,6, 0)
+    end
+  end
+
+  def test_scroll_left_down_up_right_region_enclosed_completely
+    before =  [ "aaaaaaaaaa",
+                "bbbbbbbbbb",
+                "cccccccccc",
+                "dddddddddd",
+                "eeeeeeeeee" ]
+
+    after =   [ "aaaaaaaaaa",
+                "bb     bbb",
+                "cc     ccc",
+                "dd     ddd",
+                "eeeeeeeeee" ]
+
+    # Scroll left
+    (5..10).each do |count|
+      screen_modify_test(before, after, "scroll_left_region count=#{count}") do |b|
+        b.scroll_left_region( 1,2, 3,6, count)
+      end
+    end
+
+    # Scroll down
+    (3..10).each do |count|
+      screen_modify_test(before, after, "scroll_down_region count=#{count}") do |b|
+        b.scroll_down_region( 1,2, 3,6, count)
+      end
+    end
+
+    # Scroll up
+    (3..10).each do |count|
+      screen_modify_test(before, after, "scroll_up_region count=#{count}") do |b|
+        b.scroll_up_region( 1,2, 3,6, count)
+      end
+    end
+
+    # Scroll right
+    (5..10).each do |count|
+      screen_modify_test(before, after, "scroll_right_region count=#{count}") do |b|
+        b.scroll_right_region( 1,2, 3,6, count)
+      end
+    end
+  end
+  private
+
+    def screen_modify_test(start_with, expected, message=nil)
+      raise "no block given" unless block_given?
+
+      b = ScripTTY::MultilineBuffer.new(start_with.length, start_with[0].length)
+      b.replace_at(0, 0, start_with)
+
+      # Do the operation
+      yield b
+
+      # Compare
+      assert_equal expected, b.content, message
+    end
+end