scriptty 0.5.0-java

data/test/apps/capture_app_test.rb

@@ -0,0 +1,123 @@
+# = Tests for the Capture App
+# 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/transcript/reader'
+require 'tempfile'
+
+class CaptureAppTest < Test::Unit::TestCase
+  LISTEN_PORT = 46457   # Randomly-chosen port; change if necessary
+
+  def setup
+    require 'scriptty/apps/capture_app'
+    require 'scriptty/net/event_loop'
+    raise "CaptureAppTest disabled" # FIXME
+  end
+
+  def test_basic
+    app = nil
+    app_thread = nil
+    Tempfile.open("test") do |transcript_file|
+      # Create an event loop
+      evloop = ScripTTY::Net::EventLoop.new
+
+      # Create an echo server
+      echo_server = evloop.listen(['localhost', 0])
+      echo_server.on_accept { |conn|
+        conn.on_receive_bytes { |bytes| conn.write(bytes) }
+      }
+      echo_addr = "[#{echo_server.local_address[0]}]:#{echo_server.local_address[1]}"   # format as [HOST]:PORT
+
+      # Start the capture app
+      app = ScripTTY::Apps::CaptureApp.new(%W( -l localhost:#{LISTEN_PORT} -c #{echo_addr} -o #{transcript_file.path} ))
+      app_thread = Thread.new { app.main }
+      sleep 2   # Wait for the application to bind the socket
+
+      # Connect to the capture app, and play "ping-pong" with the echo server
+      # via the capture app: Send one byte at a time, then wait for it to come
+      # back before sending the next byte.
+      bytes_to_send = "Hello".split("")
+      bytes_received = ""
+      evloop.on_connect(['localhost', LISTEN_PORT]) { |conn|
+        conn.on_close { evloop.exit }
+        write_next = nil
+        conn.on_receive_bytes { |bytes|
+          bytes_received += bytes
+          #puts "RECEIVED"
+          write_next.call
+        }
+        write_next = Proc.new {
+          unless bytes_to_send.empty?
+            #puts "WRITING"
+            conn.write(bytes_to_send.shift)
+          else
+            #puts "CLOSING"
+            conn.close
+          end
+        }
+        write_next.call
+      }
+      evloop.main
+
+      sleep 2   # Wait for the application to finish
+      app.exit
+
+      # Expected transcript
+      expected_transcript = [
+        [:client_open, "127.0.0.1", nil],
+        [:server_open, "127.0.0.1", nil],
+        [:from_client, "H"],
+        [:from_server, "H"],
+        [:from_client, "e"],
+        [:from_server, "e"],
+        [:from_client, "l"],
+        [:from_server, "l"],
+        [:from_client, "l"],
+        [:from_server, "l"],
+        [:from_client, "o"],
+        [:from_server, "o"],
+        [:client_close, "Client connection closed"],
+        [:server_close, "Server connection closed"],
+      ]
+
+      # Read transcript
+      reader = ScripTTY::Util::Transcript::Reader.new
+      raw_transcript = ""
+      actual_transcript = []
+      until transcript_file.eof?
+        line = transcript_file.readline
+        raw_transcript << line
+        timestamp, type, args = reader.parse_line(line)
+        actual_transcript << [type] + args
+      end
+
+      # Canonicalize the transcript for this test: Replace ports with nil
+      actual_transcript.each {|t|
+        if [:client_open, :server_open].include?(t[0])
+          assert_kind_of Integer, t[2], "port should be an Integer"
+          t[2] = nil
+        end
+      }
+
+      assert_equal expected_transcript, actual_transcript, raw_transcript
+    end
+  ensure
+    app.exit if app
+    app_thread.join if app_thread
+  end
+end

data/test/apps/transcript_parse_app_test.rb

@@ -0,0 +1,118 @@
+# = Tests for the TranscriptParseApp
+# 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/apps/transcript_parse_app'
+require 'scriptty/util/transcript/reader'
+require 'scriptty/util/transcript/writer'
+require 'tempfile'
+
+class TranscriptParseAppTest < Test::Unit::TestCase
+  def test_basic
+    input_events = [
+        [0.0, :client_open, '127.0.0.1', 777],
+        [0.1, :server_open, '127.0.0.1', 555],
+        [0.2, :from_client, "Hello\r\n"],
+        [1.0, :from_server, "\036~xx\001xHello\020"],
+        [1.1, :from_server, "\005\007\n\020"],
+        [2.0, :server_close, "Closed"],
+        [2.1, :client_close, "Closed"],
+    ]
+    # XXX - This isn't quite right (see below) -- the
+    # [:server_parsed,".","Hello"] comes out too late and with the wrong
+    # timestamp.
+    expected_output = [
+        [0.0, :client_open, '127.0.0.1', 777],
+        [0.1, :server_open, '127.0.0.1', 555],
+        [0.2, :from_client, "Hello\r\n"],
+        [1.0, :from_server, "\036~xx\001xHello\020"],
+        [1.0, :server_parsed, "t_proprietary_escape", "\036~xx\001x"],
+        #[1.0, :server_parsed, ".", "Hello"],    # XXX - ideally should be here
+        [1.1, :from_server, "\005\007\n\020"],
+        [1.1, :server_parsed, ".", "Hello"],    # XXX - actually is here
+        [1.1, :server_parsed, "t_write_window_address", "\020\005\007"],
+        [1.1, :server_parsed, "t_new_line", "\n"],
+        [2.0, :server_close, "Closed"],
+        [2.1, :client_close, "Closed"],
+    ]
+
+    app = nil
+    Tempfile.open("testin") do |tf_input|
+      Tempfile.open("testout") do |tf_output|
+        tf_output.close(false)
+
+        # Create the test transcript
+        writer = ScripTTY::Util::Transcript::Writer.new(tf_input)
+        input_events.each do |args|
+          timestamp, type = args.shift(2)
+          writer.override_timestamp = timestamp
+          writer.send(type, *args)
+        end
+        writer.close
+
+        ###
+        # Run the app (with --keep)
+        app = ScripTTY::Apps::TranscriptParseApp.new(%W( -o #{tf_output.path} --keep -t dg410 #{tf_input.path} ))
+        app.main
+
+        # Read transcript
+        actual_transcript = load_transcript(tf_output.path)
+
+        # Compare
+        assert_equal_transcripts expected_output, actual_transcript
+
+        ####
+        # Run the app (without --keep)
+        app = ScripTTY::Apps::TranscriptParseApp.new(%W( -o #{tf_output.path} -t dg410 #{tf_input.path} ))
+        app.main
+
+        # Read transcript
+        actual_transcript = load_transcript(tf_output.path)
+
+        # Strip :from_server from expected output
+        expected_output.reject!{|e| e[1] == :from_server}
+
+        # Compare
+        assert_equal_transcripts expected_output, actual_transcript
+      end
+    end
+  end
+
+  private
+    def load_transcript(path)
+      reader = ScripTTY::Util::Transcript::Reader.new
+      raw_transcript = ""
+      transcript = []
+      File.open(path, "r") do |transcript_file|
+        until transcript_file.eof?
+          line = transcript_file.readline
+          raw_transcript << line
+          timestamp, type, args = reader.parse_line(line)
+          transcript << [timestamp, type] + args
+        end
+      end
+      transcript
+    end
+
+    def assert_equal_transcripts(expected_transcript, actual_transcript)
+      expected_transcript.zip(actual_transcript).each_with_index do |(expected, actual), i|
+        assert_equal expected, actual, "line #{i+1}: should be equal"
+      end
+      assert_equal expected_transcript, actual_transcript, "transcripts should be equal"
+    end
+end

data/test/cursor_test.rb

@@ -0,0 +1,51 @@
+# = Tests for ScripTTY::Cursor
+# 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/cursor'
+
+class CursorTest < Test::Unit::TestCase
+  def test_row_column
+    c = ScripTTY::Cursor.new
+    assert_equal 0, c.row, "initial row value"
+    assert_equal 0, c.column, "initial column value"
+    assert_equal [0,0], c.pos, "initial pos"
+    c.row += 1
+    assert_equal 1, c.row, "row after adding 1 to row"
+    assert_equal 0, c.column, "column after adding 1 to row"
+    assert_equal [1,0], c.pos, "pos after adding 1 to row"
+    c.pos = [5,8]
+    assert_equal 5, c.row, "row after setting pos to [5,8]"
+    assert_equal 8, c.column, "column after setting pos to [5,8]"
+    assert_equal [5,8], c.pos, "pos after setting pos to [5,8]"
+  end
+
+  # Modifying the array returned by Cursor#pos should not modify the cursor
+  def test_pos_should_return_new_array
+    c = ScripTTY::Cursor.new
+    assert_equal 0, c.row, "initial row value"
+    assert_equal 0, c.column, "initial column value"
+    assert_equal [0,0], c.pos, "initial pos"
+    a = c.pos
+    a[0] += 1
+    a[1] += 1
+    assert_equal 0, c.row, "row should not change"
+    assert_equal 0, c.column, "column should not change"
+    assert_equal [0,0], c.pos, "pos should not change"
+  end
+end

data/test/fsm_definition_parser_test.rb

@@ -0,0 +1,220 @@
+# = Tests for ScripTTY::Util::FSM::DefinitionParser
+# 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/definition_parser'
+
+class FSMDefinitionParserTest < Test::Unit::TestCase
+  # Test that the parser can parse empty definitions, comments, whitespace, etc.
+  def test_empty_definitions
+    assert_equal [], parse(""), 'empty string'
+    assert_equal [], parse("\t  "), 'only whitespace'
+    assert_equal [], parse("# This is a comment"), 'comment'
+    assert_equal [], parse("   # This is a comment"), 'comment with leading whitespace'
+    assert_equal [], parse("\n\n\n"), 'blank lines'
+    assert_equal [], parse("\n\n\n    # blah\n"), 'blank lines with comment'
+  end
+
+  def test_single_quotes_must_hold_single_characters
+    definition = <<-EOF
+      'spam' => foo   # correct form is: "spam" => foo
+    EOF
+    assert_raise ArgumentError do
+      parse(definition)
+    end
+  end
+
+  def test_flat_fsm
+    expected = [
+      {:state => 1, :input => "a", :next_state => 1, :event_name => "literal_a"},
+      {:state => 1, :input => "b", :next_state => 1, :event_name => "literal_b"},
+      {:state => 1, :input => :other, :next_state => 1, :event_name => "other"},
+    ]
+    definition = <<-EOF
+      'a' => literal_a
+      'b' => literal_b
+      * => other
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  def test_nested_rules
+    expected = [
+      {:state => 1, :input => "a", :next_state => 2, :event_name => nil},
+      {:state => 2, :input => "b", :next_state => 1, :event_name => "handle_a_b"},
+      {:state => 2, :input => "c", :next_state => 1, :event_name => "handle_a_c"},
+      {:state => 2, :input => :other, :next_state => 1, :event_name => "handle_a_other"},
+      {:state => 1, :input => "b", :next_state => 1, :event_name => "handle_b"},
+      {:state => 1, :input => "c", :next_state => 3, :event_name => nil},
+      {:state => 3, :input => "a", :next_state => 1, :event_name => "handle_c_a"},
+    ]
+    definition = <<-EOF
+      'a' => {
+        'b' => handle_a_b
+        'c' => handle_a_c
+        * => handle_a_other
+      }
+      'b' => handle_b
+      'c' => {
+        'a' => handle_c_a
+      }
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  def test_nested_rule_with_comments
+    expected = [
+      {:state => 1, :input => "a", :next_state => 2, :event_name => nil},
+      {:state => 2, :input => "b", :next_state => 1, :event_name => "ab"},
+    ]
+    definition = <<-EOF
+      'a' => {      # comment 1
+        'b' => ab   # comment 2
+      }             # comment 3
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  def test_rested_rule_with_intermediate_event_name
+    expected = [
+      {:state => 1, :input => "a", :next_state => 2, :event_name => "intermediate"},
+      {:state => 2, :input => "b", :next_state => 1, :event_name => "ab"},
+    ]
+    definition = <<-EOF
+      'a' => intermediate => {
+        'b' => ab
+      }
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  def test_string_inputs
+    expected = [
+      {:state => 1, :input => "spam", :next_state => 2, :event_name => nil},
+      {:state => 2, :input => "spam", :next_state => 3, :event_name => nil},
+      {:state => 3, :input => "spam", :next_state => 4, :event_name => nil},
+      {:state => 3, :input => :other, :next_state => 1, :event_name => "not_enough_spam"},
+      {:state => 4, :input => "egg", :next_state => 1, :event_name => "rations"},
+    ]
+    definition = <<-EOF
+      "spam" => {
+        "spam" => {
+          "spam" => {
+            "egg" => rations
+          }
+          * => not_enough_spam
+        }
+      }
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  # Tabs are not allowed inside quotes.  If you want to match tabs, escape them.
+  def test_disallow_tabs_inside_quotes
+    assert_raise ArgumentError do
+      parse("\"\t\" => foo\n")
+    end
+    assert_raise ArgumentError do
+      parse("'\t' => foo\n")
+    end
+    assert_nothing_raised do
+      parse("'\\t' => foo\n")
+    end
+  end
+
+  # We should get an error on duplicate rules
+  def test_error_on_conflicting_rule
+    e = nil
+    assert_raise ArgumentError do
+      begin
+        parse(<<-EOF)
+          # Conflicts aren't necessarily obvious
+          'b' => foo
+          [a-c] => foo
+        EOF
+      rescue => e
+        raise
+      end
+    end
+    assert_match /^rule conflict/, e.message
+  end
+
+  # Single-state test of character classes
+  def test_character_classes_1state
+    expected = [
+      {:state => 1, :input => "0", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "1", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "2", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "a", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "b", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "c", :next_state => 1, :event_name => "foo"},
+      {:state => 1, :input => "x", :next_state => 1, :event_name => "foo"},
+    ]
+    definition = <<-EOF
+      [0-2a-cx] => foo
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  # Test "not" character class
+  def test_character_classes_1state_exclude
+    expected = []
+    (0..255).each { |i|
+      next if i == 0x61
+      expected << {:state => 1, :input => i.chr, :next_state => 1, :event_name => "foo"}
+    }
+    definition = <<-EOF
+      [^a] => foo
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  # Multi-state test of character classes
+  def test_character_classes_nested
+    expected = [
+      {:state => 1, :input => "0",    :next_state => 2, :event_name => nil},
+      {:state => 1, :input => "1",    :next_state => 2, :event_name => nil},
+      {:state => 1, :input => "2",    :next_state => 2, :event_name => nil},
+      {:state => 2, :input => "\x1e", :next_state => 1, :event_name => "foo"},
+      {:state => 2, :input => "\x1f", :next_state => 1, :event_name => "foo"},
+      {:state => 2, :input => " ",    :next_state => 1, :event_name => "foo"},
+      {:state => 2, :input => "!",    :next_state => 1, :event_name => "foo"},
+      {:state => 2, :input => :other, :next_state => 1, :event_name => "bar"},
+    ]
+    definition = <<-EOF
+      [0-2] => {
+        [\x1e-!] => foo
+        * => bar
+      }
+    EOF
+    assert_equal normalized(expected), normalized(parse(definition))
+  end
+
+  private
+
+    def parse(definition)
+      ::ScripTTY::Util::FSM::DefinitionParser.new.parse(definition)
+    end
+
+    def normalized(table)
+      # Set event_name to nil if missing
+      table = table.map{|r| r = r.dup; r[:event_name] ||= nil; r}
+      # Sort rows
+      table.sort{ |a,b| [a[:state], a[:input].to_s] <=> [b[:state], b[:input].to_s] }
+    end
+end