scriptty 0.5.0-java

data/test/screen_pattern/parser_test.rb

@@ -0,0 +1,266 @@
+# = Tests for ScripTTY::ScreenPattern::Parser
+# 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/screen_pattern/parser'
+
+class ParserTest < Test::Unit::TestCase
+  # Test a simple pattern
+  def test_simple_pattern
+    result = []
+    ScripTTY::ScreenPattern::Parser.parse(read_file("simple_pattern.txt")) do |screen|
+      result << screen
+    end
+    offset = [3,4]
+    expected = [{
+      :name => "simple_pattern",
+      :properties => {
+        "position" => [0,0],
+        "size" => [4,5],
+        "cursor_pos" => [0,0],
+        "matches" => [
+          [[3,2], "X"],
+        ],
+        "fields" => {
+          "field1" => [0,2..4],
+          "apple" => [1, 0..0],
+          "orange" => [1, 2..2],
+          "banana" => [1, 4..4],
+          "foo" => [2,0..1],
+          "bar" => [3,3..4],
+        },
+      },
+    }]
+    assert_equal add_pos(offset, expected), result
+  end
+
+  def test_explicit_cursor_position
+    result = []
+    ScripTTY::ScreenPattern::Parser.parse(read_file("explicit_cursor_pattern.txt")) do |screen|
+      result << screen
+    end
+    offset = [3,4]
+    expected = [{
+      :name => "simple_pattern",
+      :properties => {
+        "position" => [0,0],
+        "size" => [4,5],
+        "cursor_pos" => [1,1],
+        "fields" => {
+          "field1" => [0,2..4],
+          "apple" => [1, 0..0],
+          "orange" => [1, 2..2],
+          "banana" => [1, 4..4],
+          "foo" => [2,0..1],
+          "bar" => [3,3..4],
+        },
+      },
+    }]
+    assert_equal add_pos(offset, expected), result
+  end
+
+  def test_explicit_fields
+    result = []
+    ScripTTY::ScreenPattern::Parser.parse(read_file("explicit_fields.txt")) do |screen|
+      result << screen
+    end
+    offset = [3,4]
+    expected = [{
+      :name => "explicit_fields",
+      :properties => {
+        "position" => [0,0],
+        "size" => [4,5],
+        "cursor_pos" => [0,0],
+        "fields" => {
+          "field1" => [0,2..4],
+          "apple" => [1, 0..0],
+          "orange" => [1, 2..2],
+          "banana" => [1, 4..4],
+          "foo" => [2,0..1],
+          "bar" => [3,3..4],
+        },
+      },
+    }]
+    assert_equal add_pos(offset, expected), result
+  end
+
+  # Multiple patterns can be specified in a single file
+  def test_multiple_patterns
+    result = []
+    ScripTTY::ScreenPattern::Parser.parse(read_file("multiple_patterns.txt")) do |screen|
+      result << screen
+    end
+    expected = [
+      add_pos([3,4], {
+        :name => "simple_pattern_1",
+        :properties => {  # NB: [3,4] added to these properties
+          "position" => [0,0],
+          "size" => [4,5],
+          "cursor_pos" => [0,0],
+          "fields" => {
+            "field1" => [0,2..4],
+            "apple" => [1, 0..0],
+            "orange" => [1, 2..2],
+            "banana" => [1, 4..4],
+            "foo" => [2,0..1],
+            "bar" => [3,3..4],
+          },
+        },
+      }),
+      {
+        :name => "simple_pattern_2",
+        :properties => {
+          "position" => [0,0],
+          "size" => [4,5],
+          "cursor_pos" => [0,0],
+          "matches" => [
+            [[0,1], ":"],
+            [[2,0], "Hello"],
+            [[3,0], "World"],
+          ],
+          "fields" => {
+            "field1" => [0, 2..4],
+          },
+        },
+      },
+      {
+        :name => "simple_pattern_3",
+        :properties => {
+          "position" => [0,0],
+          "size" => [4,5],
+          "cursor_pos" => [0,0],
+          "matches" => [
+            [[0,1], ":"],
+            [[2,0], "Hello"],
+            [[3,0], "World"],
+          ],
+          "fields" => {
+            "field1" => [0, 2..4],
+          },
+        },
+      },
+    ]
+    assert_equal expected.length, result.length, "lengths do not match"
+    expected.zip(result).each do |e, r|
+      assert_equal e, r
+    end
+  end
+
+  # A here-document that's truncated should result in a parse error.
+  def test_truncated_heredoc
+    result = []
+    pattern = read_file("truncated_heredoc.txt")
+    e = nil
+    assert_raise(ArgumentError, "truncated here-document should result in parse error") do
+      begin
+        ScripTTY::ScreenPattern::Parser.parse(pattern) do |screen|
+          result << screen
+        end
+      rescue ArgumentError => e   # save exception for assertion below
+        raise
+      end
+    end
+    assert_match /^error:line 12: expected: "END", got EOF/, e.message
+  end
+
+  # UTF-16 and UTF-8 should parse correctly
+  def test_unicode
+    expected = [
+      add_pos([3,4], {
+        :name => "unicode_pattern",
+        :properties => {
+          "position" => [0,0],
+          "size" => [4,5],
+          "cursor_pos" => [0,0],
+          "fields" => {
+            "field1" => [0,2..4],
+            "apple" => [1, 0..0],
+            "orange" => [1, 2..2],
+            "banana" => [1, 4..4],
+            "foo" => [2,0..1],
+            "bar" => [3,3..4],
+          },
+        },
+      }),
+    ]
+    for filename in %w( utf16bebom_pattern.bin utf16lebom_pattern.bin utf8_pattern.bin utf8_unix_pattern.bin utf8bom_pattern.bin )
+      result = []
+      assert_nothing_raised("#{filename} should parse ok") do
+        ScripTTY::ScreenPattern::Parser.parse(read_file(filename)) do |screen|
+          result << screen
+        end
+      end
+      assert_equal expected, result, "#{filename} should parse correctly"
+    end
+  end
+
+  # Unicode NFC normalization should be performed.  This avoids user confusion if they enter two different representations of the same character.
+  def test_nfd_to_nfc_normalization
+    expected = [{
+      :name => "test",
+      :properties => {
+        "position" => [0,0],
+        "size" => [1,2],
+        "cursor_pos" => [0,1],
+      }
+    }]
+    input = <<EOF
+[test]
+char_cursor: "c\xcc\xa7"   # ASCII "c" followed by U+0327 COMBINING CEDILLA
+char_ignore: "."
+text: <<END
++--+
+|.\xc3\xa7|   # U+00E7 LATIN SMALL LETTER C WITH CEDILLA
++--+
+END
+EOF
+    result = []
+    ScripTTY::ScreenPattern::Parser.parse(input) do |screen|
+      result << screen
+    end
+    assert_equal expected, result, "NFC unicode normalization should work correctly"
+  end
+
+  private
+
+    def read_file(basename)
+      File.read(File.join(File.dirname(__FILE__), "parser_test", basename))
+    end
+
+    def add_pos(offset, arg)
+      if arg.is_a?(Array) and arg[0].is_a?(Integer) and arg[1].is_a?(Integer)
+        [offset[0]+arg[0], offset[1]+arg[1]]
+      elsif arg.is_a?(Array) and arg[0].is_a?(Integer) and arg[1].is_a?(Range)
+        [offset[0]+arg[0], offset[1]+arg[1].first..offset[1]+arg[1].last]
+      elsif arg.is_a?(Array)
+        arg.map{|a| add_pos(offset, a)}
+      elsif arg.is_a?(Hash)
+        retval = {}
+        arg.each_pair do |k,v|
+          if k == "size"
+            retval[k] = v
+          else
+            retval[k] = add_pos(offset, v)
+          end
+        end
+        retval
+      else
+        arg # raise ArgumentError.new("Don't know how to handle #{arg.inspect}")
+      end
+    end
+end

data/test/term/dg410/parser_test.rb

@@ -0,0 +1,139 @@
+# = Tests for ScripTTY::Term::DG410::Parser
+# 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/term'
+
+class ParserTest < Test::Unit::TestCase
+  def setup
+    # Tests should pass with $KCODE = "UTF8"
+    $KCODE = "UTF8"
+  end
+
+  def test_basic
+    expected_result = [
+      [:t_blink_enable, "\003"],
+      [:t_blink_disable, "\004"],
+      [:t_proprietary_ack, "\006"],
+      [:t_bell, "\007"],
+      [:t_window_home, "\010"],
+      [:t_new_line, "\n"],
+      [:t_erase_end_of_line, "\013"],
+      [:t_erase_window, "\014"],
+      [:t_carriage_return, "\015"],
+      [:t_blink_on, "\016"],
+      [:t_blink_off, "\017"],
+      [:t_write_window_address, "\020\000\000"],
+      [:t_write_window_address, "\020\006\177"],
+      [:t_print_window, "\021"],
+      [:t_roll_enable, "\022"],
+      [:t_roll_disable, "\023"],
+      [:t_underscore_on, "\024"],
+      [:t_underscore_off, "\025"],
+      [:t_cursor_up, "\027"],
+      [:t_cursor_right, "\30"],
+      [:t_cursor_left, "\031"],
+      [:t_cursor_down, "\032"],
+      [:t_osc_m, "\033]0M"],
+      [:t_osc_m, "\033]1M"],
+      [:t_osc_k, "\033]0K"],
+      [:t_osc_k, "\033]1K"],
+      [:t_dim_on, "\034"],
+      [:t_dim_off, "\035"],
+      [:t_reverse_video_on, "\036D"],
+      [:t_reverse_video_off, "\036E"],
+      [:t_reset, "\036FA"],
+      [:t_erase_unprotected, "\036FF"],
+#      [:t_delete_line, "\036FI"],
+#      [:t_set_cursor_type, "\036FQx"],
+#      [:t_delete_character, "\036K"],
+      [:t_proprietary_escape, "\036~xx\000"],
+      [:t_proprietary_escape, "\036~xx\001x"],
+      [:t_proprietary_escape, "\036~xx\002xx"],
+      [:t_proprietary_escape, "\036~xx\003xxx"],
+#      [:t_telnet_will, "\377\373\001"],
+#      [:t_telnet_wont, "\377\374\001"],
+#      [:t_telnet_do, "\377\375\001"],
+#      [:t_telnet_dont, "\377\376\001"],
+      [:t_printable, "h"],
+      [:t_printable, "e"],
+      [:t_printable, "l"],
+      [:t_printable, "l"],
+      [:t_printable, "o"],
+    ]
+    result = []
+    parser = ScripTTY::Term.class_by_name("dg410").parser_class.new :callback => Proc.new { |event, fsm|
+      result << [event, fsm.input_sequence.join]
+    }
+    # Mash the inputs together, then check that the parser splits them up properly.
+    input_string = expected_result.inject(""){|r, e| r += e[1]}
+    parser.feed_bytes(input_string)
+    assert_equal expected_result, result
+  end
+
+  def test_on_unknown_sequence_block
+    expected_result = [
+      [:t_erase_unprotected, "\036FF"],
+      [:t_printable, "o"],
+      [:UNKNOWN, "\x85"],
+      [:t_printable, "x"],
+    ]
+    result = []
+    parser = ScripTTY::Term.class_by_name("dg410").parser_class.new :callback => Proc.new { |event, fsm|
+      result << [event, fsm.input_sequence.join]
+    }
+    parser.on_unknown_sequence { |seq|
+      result << [:UNKNOWN, seq]
+    }
+    input_string = expected_result.inject(""){|r, e| r += e[1]}
+    parser.feed_bytes(input_string)
+    assert_equal expected_result, result
+  end
+
+  def test_on_unknown_sequence_ignore
+    expected_result = [
+      [:t_erase_unprotected, "\036FF"],
+      [:t_printable, "o"],
+      [:UNKNOWN, "\x80"],
+      [:t_printable, "x"],
+    ]
+    result = []
+    parser = ScripTTY::Term.class_by_name("dg410").parser_class.new :callback => Proc.new { |event, fsm|
+      result << [event, fsm.input_sequence.join]
+    }
+    parser.on_unknown_sequence :ignore
+    input_string = expected_result.inject(""){|r, e| r += e[1]}
+    parser.feed_bytes(input_string)
+    assert_equal expected_result.reject{|e| e[0] == :UNKNOWN}, result
+  end
+
+  def test_on_unknown_sequence_error
+    result = []
+    parser = ScripTTY::Term.class_by_name("dg410").parser_class.new :callback => Proc.new { |event, fsm|
+      result << [event, fsm.input_sequence.join]
+    }
+    # First iteration: test that :error is the default
+    # Second iteration: test that :error works when explicitly specified
+    2.times do
+      assert_raises ScripTTY::Util::FSM::NoMatch do
+        parser.feed_bytes("\x80")
+      end
+      parser.on_unknown_sequence :error
+    end
+  end
+end