vim-jar 0.0.1

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/helper.rb

@@ -0,0 +1,149 @@
+# Some common routines used in testing.
+
+require 'fileutils'
+require 'yaml'
+# require 'diff/lcs'
+# require 'diff/lcs/hunk'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+module TestHelper
+
+  # FIXME: turn args into a hash.
+  def run_debugger(testname, args='', outfile=nil, filter=nil, old_code=false,
+                   debug_pgm='tdebug.rb')
+    rightfile = File.join('data', "#{testname}.right")
+    
+    outfile = "#{testname}.out" unless outfile
+
+    if File.exists?(outfile)
+      FileUtils.rm(outfile)
+    end
+    
+    ENV['RDEBUG'] = debug_pgm
+    ENV['TERM']   = ''
+
+    # The EMACS environment variable(s) cause output to 
+    # get prefaced with null which will mess up file compares.
+    # So turn off EMACS output processing.
+    ENV['EMACS'] = ENV['INSIDE_EMACS'] = nil
+
+    if old_code
+      cmd = "/bin/sh #{File.join('..', 'runner.sh')} #{args} >#{outfile}"
+    else
+      cmd = "#{"#{load_ruby} #{load_params} "}../rdbg.rb #{args} > #{outfile}"
+    end
+    puts "'#{cmd}'" if $DEBUG
+    output = `#{cmd}`
+    
+    got_lines     = File.read(outfile).split(/\n/)
+    correct_lines = File.read(rightfile).split(/\n/)
+    filter.call(got_lines, correct_lines) if filter
+    if cheap_diff(got_lines, correct_lines)
+      FileUtils.rm(outfile)
+      return true
+    end
+    return false
+  end
+
+  def cheap_diff(got_lines, correct_lines)
+    if $DEBUG
+      got_lines.each_with_index do |line, i|
+        printf "%3d %s\n", i+1, line
+      end
+    end
+    correct_lines.each_with_index do |line, i|
+      correct_lines[i].chomp!
+      if got_lines[i] != correct_lines[i]
+        puts "difference found at line #{i+1}"
+        puts "got : #{got_lines[i]}"
+        puts "need: #{correct_lines[i]}"
+        return false
+      end
+    end
+    if correct_lines.size != got_lines.size
+      puts("difference in number of lines: " + 
+           "#{correct_lines.size} vs. #{got_lines.size}")
+      return false
+    end
+    return true
+  end
+
+  # FIXME: using this causes the same test to get run several times 
+  # and some tests fail probably because of a lack of environment isolation.
+  # Many tests follow a basic pattern: run the debugger with a given
+  # debugger script and compare output produced. The following creates
+  # this kind of test.
+  def add_test(base_name, src_dir, script_name=nil, cmd=nil, test_name=nil)
+    puts "+++ Adding #{base_name} ++++" if $DEBUG
+    test_name   = base_name unless test_name
+    script_name = File.join('data', test_name + '.cmd') unless script_name
+    cmd         = 'gcd.rb 3 5' unless cmd
+    eval <<-EOF
+    def test_#{test_name}
+      Dir.chdir(\"#{src_dir}\") do 
+        assert_equal(true, 
+                     run_debugger(\"#{base_name}\", 
+                                  \"--script #{script_name} -- #{cmd}\"))
+      end
+    end
+    EOF
+  end
+  module_function :add_test
+               
+  # Adapted from the Ruby Cookbook, Section 6.10: Comparing two files.
+  # def diff_as_string(rightfile, checkfile, format=:unified, context_lines=3)
+  #   right_data = File.read(rightfile)
+  #   check_data = File.read(checkfile)
+  #   output = ''
+  #   diffs = Diff::LCS.diff(right_data, check_data)
+  #   return output if diffs.empty?
+  #   oldhunk = hunk = nil
+  #   file_length_difference = 0
+  #   diffs.each do |piece|
+  #     begin
+  #       hunk = Diff::LCS::Hunk.new(right_data, check_data, piece, 
+  #                                  context_lines, file_length_difference)
+  #       next unless oldhunk
+  #
+  #       # Hunks may overlap, which is why we need to be careful when our
+  #       # diff includes lines of context. Otherwise, we might print
+  #       # redundant lines.
+  #       if (context_lines > 0) and hunk.overlaps?(oldhunk)
+  #         hunk.unshift(oldhunk)
+  #         else
+  #         output << oldhunk.diff(format)
+  #       end
+  #     ensure
+  #       oldhunk = hunk
+  #       output << '\n'
+  #     end
+  #   end
+  
+  #   # Handle the last remaining hunk 
+  #   output << oldhunk.diff(format) << '\n'
+  # end
+  
+  # Loads key from the _config_._yaml_ file.
+  def config_load(key, may_be_nil=false, default_value='')
+    conf = File.join('config.private.yaml') # try private first
+    conf = File.join('config.yaml') unless File.exists?(conf)
+    value = YAML.load_file(conf)[key]
+    assert_not_nil(value, "#{key} is set in config.yaml") unless may_be_nil
+    value || default_value
+  end
+  module_function :config_load
+
+  def load_ruby
+    config_load('ruby', true)
+  end
+  module_function :load_ruby
+
+  def load_params
+    config_load('ruby_params', true)
+  end
+  module_function :load_params
+  
+end
+

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/info-var-bug.rb

@@ -0,0 +1,47 @@
+class Lousy_inspect
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'
+  end
+end
+class Lousy_inspect_and_to_s
+  attr_accessor :var
+  def inspect    # An unhelpful inspect
+    throw "Foo"  # Raises an exception
+  end
+  def to_s       # An unhelpful to_s
+    throw "bar"  # Raises an exception
+  end
+  def initialize
+    @var = 'initialized'  # Something to inspect
+  end
+end
+
+# Something that will be passed objects with
+# bad inspect or to_s methods
+class UnsuspectingClass
+  @@Const = 'A constant'
+  @@var = 'a class variable'
+  def initialize(a)
+    @a = a      # "info locals" will try to use
+                # inspect or to_s here
+    @b = 5
+  end
+end
+def test_Lousy_inspect
+  x = Lousy_inspect.new
+  return x
+end
+def test_lousy_inspect_and_to_s
+  x = Lousy_inspect_and_to_s.new
+  return x
+end
+x = test_Lousy_inspect
+y = test_lousy_inspect_and_to_s
+UnsuspectingClass.new(10)
+UnsuspectingClass.new(x)
+UnsuspectingClass.new(y)
+y = 2

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/info-var-bug2.rb

@@ -0,0 +1,2 @@
+s = '<%= PRODUCT[:name] %>'
+y = 0

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/null.rb

@@ -0,0 +1 @@
+# Nothing here. Move along.

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/output.rb

@@ -0,0 +1,2 @@
+puts "one"
+puts "two"

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/pm-base.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Test post-mortem handling using only ruby-debug-base.
+src_dir = File.dirname(__FILE__)
+%w(ext lib cli).each do |dir|
+  $:.unshift  File.join(src_dir, '..', dir)
+end
+require 'ruby-debug-base'
+
+class CommandProcessor
+  def at_line(context, file, line)
+    puts 'file: %s, line: %s' % [ File.basename(file), line ]
+    exit!
+  end
+end
+
+Debugger.start(:post_mortem => true)
+Debugger.handler = CommandProcessor.new
+def zero_div
+  1/0
+end
+zero_div
+

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/pm-bug.rb

@@ -0,0 +1,3 @@
+a = 1
+@x = 2
+raise

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/pm.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# Test Debugger.catchpoint and post-mortem handling
+def zero_div
+  x = 5
+  1/0
+end
+x = 2
+zero_div
+raise RuntimeError
+x = 3
+

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/raise.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+raise "abc"

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/rdebug-save.1

@@ -0,0 +1,7 @@
+break gcd.rb:10
+break gcd.rb:12 if a > b
+set autoeval on
+set basename off
+set debuggertesting off
+set autolist off
+set autoirb off

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/scope-test.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'ruby-debug'
+Debugger.start
+1.times do
+  a = 1
+  debugger(0)
+end
+y = 1

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/tdebug.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+# -*- Ruby -*-
+# This is a hacked down copy of rdebug which can be used for testing
+# FIXME: use the real rdebug script - DRY.
+
+require 'stringio'
+require 'rubygems'
+require 'optparse'
+require "ostruct"
+
+TOP_SRC_DIR = File.join(File.dirname(__FILE__), "..") unless 
+  defined?(TOP_SRC_DIR)
+
+$:.unshift File.join(TOP_SRC_DIR, "ext")
+$:.unshift File.join(TOP_SRC_DIR, "lib")
+$:.unshift File.join(TOP_SRC_DIR, "cli")
+
+def debug_program(options)
+  # Make sure Ruby script syntax checks okay.
+  # Otherwise we get a load message that looks like rdebug has 
+  # a problem. 
+  output = `ruby -c #{Debugger::PROG_SCRIPT.inspect} 2>&1`
+  if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+    puts output
+    exit $?.exitstatus 
+  end
+  print "\032\032starting\n" if Debugger.annotate and Debugger.annotate > 2
+  unless options.no_rewrite_program
+    # Set $0 so things like __FILE == $0 work.
+    # A more reliable way to do this is to put $0 = __FILE__ *after*
+    # loading the script to be debugged.  For this, adding a debug hook
+    # for the first time and then switching to the debug hook that's
+    # normally used would be helpful. Doing this would also help other
+    # first-time initializations such as reloading debugger state
+    # after a restart. 
+
+    # However This is just a little more than I want to take on right
+    # now, so I think I'll stick with the slightly hacky approach.
+    $RDEBUG_0 = $0
+
+    # cygwin does some sort of funky truncation on $0 ./abcdef => ./ab
+    # probably something to do with 3-letter extension truncation.
+    # The hacky workaround is to do slice assignment. Ugh.
+    d0 = if '.' == File.dirname(Debugger::PROG_SCRIPT) and
+             Debugger::PROG_SCRIPT[0..0] != '.'
+           File.join('.', Debugger::PROG_SCRIPT)
+         else
+           Debugger::PROG_SCRIPT
+         end
+    if $0.frozen?
+      $0 = d0
+    else
+      $0[0..-1] = d0
+    end
+  end
+
+  # Record where we are we can know if the call stack has been
+  # truncated or not.
+  Debugger.start_sentinal=caller(0)[1]
+
+  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, !options.nostop, false)
+  if bt
+    if options.post_mortem
+      Debugger.handle_post_mortem(bt)
+    else
+      print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+      print "Uncaught exception: #{bt}\n"
+    end
+  end
+end
+
+options = OpenStruct.new(
+  'annotate'    => false,
+  'emacs'       => false,
+  'frame_bind'  => false,
+  'no-quit'     => false,
+  'no-stop'     => false,
+  'nx'          => false,
+  'post_mortem' => false,
+  'script'      => nil,
+  'tracing'     => false,
+  'verbose_long'=> false,
+  'wait'        => false
+)
+
+require "ruby-debug"
+
+program = File.basename($0)
+opts = OptionParser.new do |opts|
+  opts.banner = <<EOB
+#{program} #{Debugger::VERSION}
+Usage: #{program} [options] <script.rb> -- <script.rb parameters>
+EOB
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do 
+    |Debugger.annotate|
+  end
+  opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
+  opts.on("--emacs-basic", "Activates basic Emacs mode") do 
+    ENV['EMACS'] = '1'
+    options.emacs = true
+  end
+  opts.on("--keep-frame-binding", "Keep frame bindings") do 
+    options.frame_bind = true
+  end
+  opts.on("-m", "--post-mortem", "Activate post-mortem mode") do 
+    options.post_mortem = true
+  end
+  opts.on("--no-control", "Do not automatically start control thread") do 
+    options.control = false
+  end
+  opts.on("--no-quit", "Do not quit when script finishes") do
+    options.noquit = true
+  end
+  opts.on("--no-stop", "Do not stop when script is loaded") do 
+    options.nostop = true
+  end
+  opts.on("-nx", "Not run debugger initialization files (e.g. .rdebugrc") do
+    options.nx = true
+  end
+  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
+    $LOAD_PATH.unshift(path)
+  end
+  opts.on("-r", "--require SCRIPT", String,
+          "Require the library, before executing your script") do |name|
+    if name == 'debug'
+      puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
+    else
+      require name
+    end
+  end
+  opts.on("--script FILE", String, "Name of the script file to run") do |options.script| 
+    unless File.exists?(options.script)
+      puts "Script file '#{options.script}' is not found"
+      exit
+    end
+  end
+  opts.on("-x", "--trace", "Turn on line tracing") {options.tracing = true}
+  ENV['EMACS'] = nil unless options.emacs
+  opts.separator ""
+  opts.separator "Common options:"
+  opts.on_tail("--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on_tail("--version", 
+               "Print the version") do
+    puts "ruby-debug #{Debugger::VERSION}"
+    exit
+  end
+  opts.on("--verbose", "Turn on verbose mode") do
+    $VERBOSE = true
+    options.verbose_long = true
+  end
+  opts.on_tail("-v", 
+               "Print version number, then turn on verbose mode") do
+    puts "ruby-debug #{Debugger::VERSION}"
+    $VERBOSE = true
+  end
+end
+
+begin
+  if not defined? Debugger::ARGV
+    Debugger::ARGV = ARGV.clone
+  end
+  rdebug_path = File.expand_path($0)
+  if RUBY_PLATFORM =~ /mswin/
+    rdebug_path += '.cmd' unless rdebug_path =~ /\.cmd$/i
+  end
+  Debugger::RDEBUG_SCRIPT = rdebug_path
+  Debugger::RDEBUG_FILE = __FILE__
+  Debugger::INITIAL_DIR = Dir.pwd
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+end
+
+if ARGV.empty?
+  exit if $VERBOSE and not options.verbose_long
+  puts opts
+  puts
+  puts 'Must specify a script to run'
+  exit(-1)
+end
+  
+# save script name
+Debugger::PROG_SCRIPT = ARGV.shift
+
+# install interruption handler
+trap('INT') { Debugger.interrupt_last }
+
+# set options
+Debugger.wait_connection = false
+Debugger.keep_frame_binding = options.frame_bind
+
+# Add Debugger trace hook.
+Debugger.start
+
+# start control thread
+Debugger.start_control(options.host, options.cport) if options.control
+
+# activate post-mortem
+Debugger.post_mortem if options.post_mortem
+
+# Set up an interface to read commands from a debugger script file.
+if options.script
+  Debugger.interface = Debugger::ScriptInterface.new(options.script, 
+                                                     STDOUT, true)
+end
+options.nostop = true if options.tracing
+Debugger.tracing = options.tracing
+
+# Make sure Ruby script syntax checks okay.
+# Otherwise we get a load message that looks like rdebug has 
+# a problem. 
+output = `ruby -c #{Debugger::PROG_SCRIPT.inspect} 2>&1`
+if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+  puts output
+  exit $?.exitstatus 
+end
+
+# load initrc script (e.g. .rdebugrc)
+Debugger.run_init_script(StringIO.new) unless options.nx
+
+# run startup script if specified
+if options.script
+  Debugger.run_script(options.script)
+end
+# activate post-mortem
+Debugger.post_mortem if options.post_mortem
+options.stop = false if options.tracing
+Debugger.tracing = options.tracing
+
+if options.noquit
+  if Debugger.started?
+    until Debugger.stop do end
+  end
+  debug_program(options)
+  print "The program finished.\n" unless 
+    Debugger.annotate.to_i > 1 # annotate has its own way
+  interface = Debugger::LocalInterface.new
+  # Not sure if ControlCommandProcessor is really the right
+  # thing to use. CommandProcessor requires a state.
+  processor = Debugger::ControlCommandProcessor.new(interface)
+  processor.process_commands
+else
+  debug_program(options)
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-annotate.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require 'fileutils'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test annotate handling.
+class TestAnnotate < Test::Unit::TestCase
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='annotate'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-break-bad.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test (mostly) invalid breakpoint commands
+class TestBadBreak < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='break_bad'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+  
+  def test_break_loop
+    testname='break_loop_bug'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+        run_debugger(testname,
+          "--script #{script} -- bp_loop_issue.rb"))
+    end
+  end
+
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-breakpoints.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test breakpoint commands
+class TestBreakpoints < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='breakpoints'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-brkpt-class-bug.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test (mostly) invalid breakpoint commands
+class TestBrkptClassBug < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='brkpt-class-bug'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- brkpt-class-bug.rb"))
+    end
+  end
+  
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-catch.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test condition command
+class TestCatch < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='catch'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- pm.rb"))
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/test/test-condition.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+
+# begin require 'rubygems' rescue LoadError end
+# require 'ruby-debug'; Debugger.start
+
+# Test condition command
+class TestCondition < Test::Unit::TestCase
+
+  @@SRC_DIR = File.dirname(__FILE__) unless 
+    defined?(@@SRC_DIR)
+
+  require File.join(@@SRC_DIR, 'helper')
+  include TestHelper
+
+  def test_basic
+    testname='condition'
+    Dir.chdir(@@SRC_DIR) do 
+      script = File.join('data', testname + '.cmd')
+      assert_equal(true, 
+                   run_debugger(testname,
+                                "--script #{script} -- gcd.rb 3 5"))
+    end
+  end
+end