/Languages/Ruby/Tests/Libraries/ParseTreeTests/pt_testcase.rb

Large files files are truncated, but you can click here to view the full file

$TESTING = true

require 'minitest/unit'
require 'sexp_processor' # for deep_clone

# key:
# wwtt = what were they thinking?

# TODO: <ko1_> 1.8.7 support {|&b|} syntax

class Examples
  attr_reader :reader
  attr_writer :writer

  def a_method(x); x+1; end
  alias an_alias a_method

  define_method(:bmethod_noargs) do
    x + 1
  end

  define_method(:unsplatted) do |x|
    x + 1
  end

  define_method :splatted do |*args|
    y = args.first
    y + 42
  end

  define_method :dmethod_added, instance_method(:a_method) if
    RUBY_VERSION < "1.9"
end

class ParseTreeTestCase < MiniTest::Unit::TestCase
  attr_accessor :processor # to be defined by subclass

  def setup
    super
    @processor = nil
  end

  def after_process_hook klass, node, data, input_name, output_name
  end

  def before_process_hook klass, node, data, input_name, output_name
  end

  def self.add_test name, data, klass = self.name[4..-1]
    name = name.to_s
    klass = klass.to_s

    if testcases.has_key? name then
      if testcases[name].has_key? klass then
        warn "testcase #{klass}##{name} already has data"
      else
        testcases[name][klass] = data
      end
    else
      warn "testcase #{name} does not exist"
    end
  end

  def self.add_tests name, hash
    name = name.to_s

    hash.each do |klass, data|
      warn "testcase #{klass}##{name} already has data" if
        testcases[name].has_key? klass
      testcases[name][klass] = data
    end
  end

  def self.clone_same
    @@testcases.each do |node, data|
      data.each do |key, val|
        if val == :same then
          prev_key = self.previous(key)
          data[key] = data[prev_key].deep_clone
        end
      end
    end
  end

  def self.copy_test_case nonverbose, klass
    verbose = nonverbose + "_mri_verbose_flag"
    testcases[verbose][klass] = testcases[nonverbose][klass]
  end

  def self.generate_test klass, node, data, input_name, output_name
    klass.send(:define_method, "test_#{node}".to_sym) do
      flunk "Processor is nil" if processor.nil?

      assert data.has_key?(input_name), "Unknown input data"
      assert data.has_key?(output_name), "Missing test data"

      $missing[node] << output_name unless data.has_key? output_name

      input    = data[input_name].deep_clone
      expected = data[output_name].deep_clone

      case expected
      when :unsupported then
        assert_raises(UnsupportedNodeError) do
          processor.process(input)
        end
      else
        extra_expected = []
        extra_input = []

        _, expected, extra_expected = *expected if
          Array === expected and expected.first == :defx
        _, input, extra_input = *input if
          Array === input and input.first == :defx

        # OMG... I can't believe I have to do this this way.  these
        # hooks are here instead of refactoring this define_method
        # body into an assertion. It'll allow subclasses to hook in
        # and add behavior before or after the processor does it's
        # thing. If you go the body refactor route, some of the
        # RawParseTree test casese fail for completely bogus reasons.

        before_process_hook klass, node, data, input_name, output_name
        refute_nil data[input_name], "testcase does not exist?"
        @result = processor.process input
        assert_equal(expected, @result,
                     "failed on input: #{data[input_name].inspect}")
        after_process_hook klass, node, data, input_name, output_name

        extra_input.each do |extra|
          processor.process(extra)
        end
        extra = processor.extra_methods rescue []
        assert_equal extra_expected, extra
      end
    end
  end

  def self.generate_tests klass
    install_missing_reporter
    clone_same

    output_name = klass.name.to_s.sub(/^Test/, '')

    input_name = self.previous(output_name)

    @@testcases.each do |node, data|
      next if [:skip, :unsupported].include? data[input_name]
      next if data[output_name] == :skip

      generate_test klass, node, data, input_name, output_name
    end
  end

  def self.inherited klass
    super

    generate_tests klass unless klass.name =~ /TestCase/
  end

  def self.install_missing_reporter
    unless defined? $missing then
      $missing = Hash.new { |h,k| h[k] = [] }
      at_exit {
        at_exit {
          warn ""
          $missing.sort.each do |name, klasses|
            warn "add_tests(#{name.inspect},"
            klasses.map! { |klass| "          #{klass.inspect} => :same" }
            warn klasses.join("\n") + ")"
          end
          warn ""
        }
      }
    end
  end

  def self.previous(key, extra=0) # FIX: remove R2C code
    idx = @@testcase_order.index(key)

    raise "Unknown class #{key} in @@testcase_order" if idx.nil?

    case key
    when "RubyToRubyC" then
      idx -= 1
    end
    @@testcase_order[idx - 1 - extra]
  end

  def self.testcase_order; @@testcase_order; end
  def self.testcases; @@testcases; end

  def self.unsupported_tests *tests
    tests.flatten.each do |name|
      add_test name, :unsupported
    end
  end

  ############################################################
  # Shared TestCases:

  @@testcase_order = %w(Ruby RawParseTree ParseTree)

  @@testcases = Hash.new { |h,k| h[k] = {} }

  add_tests("alias",
            "Ruby"         => "class X\n  alias :y :x\nend",
            "RawParseTree" => [:class, :X, nil,
                               [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
            "ParseTree"    => s(:class, :X, nil,
                                s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))))

  add_tests("alias_ugh",
            "Ruby"         => "class X\n  alias y x\nend",
            "RawParseTree" => [:class, :X, nil,
                               [:scope, [:alias, [:lit, :y], [:lit, :x]]]],
            "ParseTree"    => s(:class, :X, nil,
                                s(:scope, s(:alias, s(:lit, :y), s(:lit, :x)))),
            "Ruby2Ruby"    => "class X\n  alias :y :x\nend")

  add_tests("and",
            "Ruby"         => "(a and b)",
            "RawParseTree" => [:and, [:vcall, :a], [:vcall, :b]],
            "ParseTree"    => s(:and,
                                s(:call, nil, :a, s(:arglist)),
                                s(:call, nil, :b, s(:arglist))))

  add_tests("argscat_inside",
            "Ruby"         => "a = [b, *c]",
            "RawParseTree" => [:lasgn, :a,
                               [:argscat,
                                [:array, [:vcall, :b]], [:vcall, :c]]],
            "ParseTree"    => s(:lasgn, :a,
                                s(:array,
                                  s(:call, nil, :b, s(:arglist)),
                                  s(:splat, s(:call, nil, :c, s(:arglist))))))

  add_tests("argscat_svalue",
            "Ruby"         => "a = b, c, *d",
            "RawParseTree" => [:lasgn, :a,
                               [:svalue,
                                [:argscat,
                                 [:array, [:vcall, :b], [:vcall, :c]],
                                 [:vcall, :d]]]],
            "ParseTree"    => s(:lasgn, :a,
                                s(:svalue,
                                  s(:array,
                                    s(:call, nil, :b, s(:arglist)),
                                    s(:call, nil, :c, s(:arglist)),
                                    s(:splat,
                                      s(:call, nil, :d, s(:arglist)))))))

  add_tests("argspush",
            "Ruby"         => "a[*b] = c",
            "RawParseTree" => [:attrasgn,
                               [:vcall, :a],
                               :[]=,
                               [:argspush,
                                [:splat,
                                 [:vcall, :b]],
                                [:vcall, :c]]],
            "ParseTree"    => s(:attrasgn,
                                s(:call, nil, :a, s(:arglist)),
                                :[]=,
                                s(:arglist,
                                  s(:splat,
                                    s(:call, nil, :b, s(:arglist))),
                                  s(:call, nil, :c, s(:arglist)))))

  add_tests("array",
            "Ruby"         => "[1, :b, \"c\"]",
            "RawParseTree" => [:array, [:lit, 1], [:lit, :b], [:str, "c"]],
            "ParseTree"    => s(:array, s(:lit, 1), s(:lit, :b), s(:str, "c")))

  add_tests("array_pct_W",
            "Ruby"         => "%W[a b c]",
            "RawParseTree" => [:array, [:str, "a"], [:str, "b"], [:str, "c"]],
            "ParseTree"    => s(:array,
                                s(:str, "a"), s(:str, "b"), s(:str, "c")),
            "Ruby2Ruby"    => "[\"a\", \"b\", \"c\"]")

  add_tests("array_pct_W_dstr",
            "Ruby"         => "%W[a #\{@b} c]",
            "RawParseTree" => [:array,
                               [:str, "a"],
                               [:dstr, "", [:evstr, [:ivar, :@b]]],
                               [:str, "c"]],
            "ParseTree"    => s(:array,
                                s(:str, "a"),
                                s(:dstr, "", s(:evstr, s(:ivar, :@b))),
                                s(:str, "c")),
            "Ruby2Ruby"    => "[\"a\", \"#\{@b}\", \"c\"]")

  add_tests("array_pct_w",
            "Ruby"         => "%w[a b c]",
            "RawParseTree" => [:array, [:str, "a"], [:str, "b"], [:str, "c"]],
            "ParseTree"    => s(:array,
                                s(:str, "a"), s(:str, "b"), s(:str, "c")),
            "Ruby2Ruby"    => "[\"a\", \"b\", \"c\"]")

  add_tests("array_pct_w_dstr",
            "Ruby"         => "%w[a #\{@b} c]",
            "RawParseTree" => [:array,
                               [:str, "a"],
                               [:str, "#\{@b}"],
                               [:str, "c"]],
            "ParseTree"    => s(:array,
                                s(:str, "a"),
                                s(:str, "#\{@b}"),
                                s(:str, "c")),
            "Ruby2Ruby"    => "[\"a\", \"\\\#{@b}\", \"c\"]") # TODO: huh?

  add_tests("attrasgn",
            "Ruby"         => "y = 0\n42.method = y\n",
            "RawParseTree" => [:block,
                               [:lasgn, :y, [:lit, 0]],
                               [:attrasgn, [:lit, 42], :method=,
                                [:array, [:lvar, :y]]]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :y, s(:lit, 0)),
                                s(:attrasgn, s(:lit, 42), :method=,
                                  s(:arglist, s(:lvar, :y)))))

  add_tests("attrasgn_index_equals",
            "Ruby"         => "a[42] = 24",
            "RawParseTree" => [:attrasgn, [:vcall, :a], :[]=,
                               [:array, [:lit, 42], [:lit, 24]]],
            "ParseTree"    => s(:attrasgn,
                                s(:call, nil, :a, s(:arglist)),
                                :[]=,
                                s(:arglist, s(:lit, 42), s(:lit, 24))))

  add_tests("attrasgn_index_equals_space",
            "Ruby"         => "a = []; a [42] = 24",
            "RawParseTree" => [:block,
                               [:lasgn, :a, [:zarray]],
                               [:attrasgn, [:lvar, :a], :[]=,
                                [:array, [:lit, 42], [:lit, 24]]]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :a, s(:array)),
                                s(:attrasgn, s(:lvar, :a), :[]=,
                                  s(:arglist, s(:lit, 42), s(:lit, 24)))),
            "Ruby2Ruby"    => "a = []\na[42] = 24\n")

  add_tests("attrset",
            "Ruby"         => [Examples, :writer=],
            "RawParseTree" => [:defn, :writer=, [:attrset, :@writer]],
            "ParseTree"    => s(:defn, :writer=,
                                s(:args, :arg),
                                s(:attrset, :@writer)),
            "Ruby2Ruby"    => "attr_writer :writer")

  add_tests("back_ref",
            "Ruby"         => "[$&, $`, $', $+]",
            "RawParseTree" => [:array,
                               [:back_ref, :&],
                               [:back_ref, :"`"],
                               [:back_ref, :"'"],
                               [:back_ref, :+]],
            "ParseTree"    => s(:array,
                                s(:back_ref, :&),
                                s(:back_ref, :"`"),
                                s(:back_ref, :"'"),
                                s(:back_ref, :+)))

  add_tests("begin",
            "Ruby"         => "begin\n  (1 + 1)\nend",
            "RawParseTree" => [:call, [:lit, 1], :+, [:array, [:lit, 1]]],
            "ParseTree"    => s(:call, s(:lit, 1), :+,
                                s(:arglist, s(:lit, 1))),
            "Ruby2Ruby"    => "(1 + 1)")

  add_tests("begin_def",
            "Ruby"         => "def m\n  begin\n\n  end\nend",
            "RawParseTree" => [:defn, :m, [:scope, [:block, [:args], [:nil]]]],
            "ParseTree"    => s(:defn, :m, s(:args),
                                s(:scope, s(:block, s(:nil)))),
            "Ruby2Ruby"    => "def m\n  # do nothing\nend")

  add_tests("begin_rescue_ensure",
            "Ruby"         => "begin\n  a\nrescue\n  # do nothing\nensure\n  # do nothing\nend",
            "RawParseTree" => [:ensure,
                               [:rescue,
                                [:vcall, :a],
                                [:resbody, nil]],
                               [:nil]],
            "ParseTree"    => s(:ensure,
                                s(:rescue,
                                  s(:call, nil, :a, s(:arglist)),
                                  s(:resbody, s(:array), nil)),
                                s(:nil)))

  add_tests("begin_rescue_ensure_all_empty",
            "Ruby"         => "begin\n  # do nothing\nrescue\n  # do nothing\nensure\n  # do nothing\nend",
            "RawParseTree" => [:ensure,
                               [:rescue,
                                [:resbody, nil]],
                               [:nil]],
            "ParseTree"    => s(:ensure,
                                s(:rescue,
                                  s(:resbody, s(:array), nil)),
                                s(:nil)))

  add_tests("begin_rescue_twice",
            "Ruby"         => "begin\n  a\nrescue => mes\n  # do nothing\nend\nbegin\n  b\nrescue => mes\n  # do nothing\nend\n",
            "RawParseTree" => [:block,
                               [:rescue,
                                [:vcall, :a],
                                [:resbody, nil,
                                 [:lasgn, :mes, [:gvar, :$!]]]],
                               [:rescue,
                                [:vcall, :b],
                                [:resbody, nil,
                                 [:lasgn, :mes, [:gvar, :$!]]]]],
            "ParseTree"    => s(:block,
                                s(:rescue,
                                  s(:call, nil, :a, s(:arglist)),
                                  s(:resbody,
                                    s(:array, s(:lasgn, :mes, s(:gvar, :$!))),
                                    nil)),
                                s(:rescue,
                                  s(:call, nil, :b, s(:arglist)),
                                  s(:resbody,
                                    s(:array,
                                      s(:lasgn, :mes, s(:gvar, :$!))),
                                    nil))))

  add_tests("begin_rescue_twice_mri_verbose_flag",
            "RawParseTree" => [:block,
                               [:rescue,                # no begin
                                [:vcall, :a],
                                [:resbody, nil,
                                 [:lasgn, :mes, [:gvar, :$!]]]],
                               [:rescue,
                                [:vcall, :b],
                                [:resbody, nil,
                                 [:lasgn, :mes, [:gvar, :$!]]]]])

  copy_test_case "begin_rescue_twice", "Ruby"
  copy_test_case "begin_rescue_twice", "ParseTree"

  add_tests("block_attrasgn",
            "Ruby" => "def self.setup(ctx)\n  bind = allocate\n  bind.context = ctx\n  return bind\nend",
            "RawParseTree" => [:defs, [:self], :setup,
                               [:scope,
                                [:block,
                                 [:args, :ctx],
                                 [:lasgn, :bind, [:vcall, :allocate]],
                                 [:attrasgn, [:lvar, :bind], :context=,
                                  [:array, [:lvar, :ctx]]],
                                 [:return, [:lvar, :bind]]]]],
            "ParseTree" => s(:defs, s(:self), :setup,
                             s(:args, :ctx),
                             s(:scope,
                               s(:block,
                                 s(:lasgn, :bind,
                                   s(:call, nil, :allocate, s(:arglist))),
                                 s(:attrasgn, s(:lvar, :bind), :context=,
                                   s(:arglist, s(:lvar, :ctx))),
                                 s(:return, s(:lvar, :bind))))))


  add_tests("block_lasgn",
            "Ruby"         => "x = (y = 1\n(y + 2))",
            "RawParseTree" => [:lasgn, :x,
                               [:block,
                                [:lasgn, :y, [:lit, 1]],
                                [:call, [:lvar, :y], :+, [:array, [:lit, 2]]]]],
            "ParseTree"    => s(:lasgn, :x,
                                s(:block,
                                  s(:lasgn, :y, s(:lit, 1)),
                                  s(:call, s(:lvar, :y), :+,
                                    s(:arglist, s(:lit, 2))))))

  add_tests("block_mystery_block",
            "Ruby"         => "a(b) do\n  if b then\n    true\n  else\n    c = false\n    d { |x| c = true }\n    c\n  end\nend",
            "RawParseTree" => [:iter,
                               [:fcall, :a, [:array, [:vcall, :b]]],
                               nil,
                               [:if,
                                [:vcall, :b],
                                [:true],
                                [:block,
                                 [:dasgn_curr, :c, [:false]],
                                 [:iter,
                                  [:fcall, :d],
                                  [:dasgn_curr, :x],
                                  [:dasgn, :c, [:true]]],
                                 [:dvar, :c]]]],
            "ParseTree"    => s(:iter,
                                s(:call, nil, :a,
                                  s(:arglist, s(:call, nil, :b, s(:arglist)))),
                                nil,
                                s(:if,
                                  s(:call, nil, :b, s(:arglist)),
                                  s(:true),
                                  s(:block,
                                    s(:lasgn, :c, s(:false)),
                                    s(:iter,
                                      s(:call, nil, :d, s(:arglist)),
                                      s(:lasgn, :x),
                                      s(:lasgn, :c, s(:true))),
                                    s(:lvar, :c)))))

  add_tests("block_pass_args_and_splat",
            "Ruby"         => "def blah(*args, &block)\n  other(42, *args, &block)\nend",
            "RawParseTree" => [:defn, :blah,
                               [:scope,
                                [:block,
                                 [:args, :"*args"],
                                 [:block_arg, :block],
                                 [:block_pass,
                                  [:lvar, :block],
                                  [:fcall, :other,
                                   [:argscat,
                                    [:array, [:lit, 42]], [:lvar, :args]]]]]]],
            "ParseTree"    => s(:defn, :blah,
                                s(:args, :"*args", :"&block"),
                                s(:scope,
                                  s(:block,
                                    s(:call, nil, :other,
                                      s(:arglist,
                                        s(:lit, 42),
                                        s(:splat, s(:lvar, :args)),
                                        s(:block_pass, s(:lvar, :block))))))))

  add_tests("block_pass_call_0",
            "Ruby"         => "a.b(&c)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :c], [:call, [:vcall, :a], :b]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :a, s(:arglist)),
                                :b,
                                s(:arglist,
                                  s(:block_pass,
                                    s(:call, nil, :c, s(:arglist))))))

  add_tests("block_pass_call_1",
            "Ruby"         => "a.b(4, &c)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :c],
                               [:call, [:vcall, :a], :b, [:array, [:lit, 4]]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :a, s(:arglist)),
                                :b,
                                s(:arglist,
                                  s(:lit, 4),
                                  s(:block_pass,
                                    s(:call, nil, :c, s(:arglist))))))

  add_tests("block_pass_call_n",
            "Ruby"         => "a.b(1, 2, 3, &c)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :c],
                               [:call, [:vcall, :a], :b,
                                [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :a, s(:arglist)),
                                :b,
                                s(:arglist,
                                  s(:lit, 1), s(:lit, 2), s(:lit, 3),
                                  s(:block_pass,
                                    s(:call, nil, :c, s(:arglist))))))

  add_tests("block_pass_fcall_0",
            "Ruby"         => "a(&b)",
            "RawParseTree" => [:block_pass, [:vcall, :b], [:fcall, :a]],
            "ParseTree"    => s(:call, nil, :a,
                                s(:arglist,
                                  s(:block_pass,
                                    s(:call, nil, :b, s(:arglist))))))

  add_tests("block_pass_fcall_1",
            "Ruby"         => "a(4, &b)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :b],
                               [:fcall, :a, [:array, [:lit, 4]]]],
            "ParseTree"    => s(:call, nil, :a,
                                s(:arglist,
                                  s(:lit, 4),
                                  s(:block_pass,
                                    s(:call, nil, :b, s(:arglist))))))

  add_tests("block_pass_fcall_n",
            "Ruby"         => "a(1, 2, 3, &b)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :b],
                               [:fcall, :a,
                                [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]],
            "ParseTree"    => s(:call, nil, :a,
                                s(:arglist,
                                  s(:lit, 1), s(:lit, 2), s(:lit, 3),
                                  s(:block_pass,
                                    s(:call, nil, :b, s(:arglist))))))

  add_tests("block_pass_omgwtf",
            "Ruby"         => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
            "RawParseTree" => [:block_pass,
                               [:iter,
                                [:call, [:const, :Proc], :new],
                                [:masgn, nil, [:dasgn_curr, :args], nil],
                                [:nil]],
                               [:fcall, :define_attr_method,
                                [:array, [:lit, :x], [:lit, :sequence_name]]]],
            "ParseTree"    => s(:call, nil, :define_attr_method,
                                s(:arglist,
                                  s(:lit, :x),
                                  s(:lit, :sequence_name),
                                  s(:block_pass,
                                    s(:iter,
                                      s(:call, s(:const, :Proc), :new,
                                        s(:arglist)),
                                      s(:masgn,
                                        s(:array, s(:splat, s(:lasgn, :args)))),
                                      s(:nil))))))

  add_tests("block_pass_splat",
            "Ruby"         => "def blah(*args, &block)\n  other(*args, &block)\nend",
            "RawParseTree" => [:defn, :blah,
                               [:scope,
                                [:block,
                                 [:args, :"*args"],
                                 [:block_arg, :block],
                                 [:block_pass,
                                  [:lvar, :block],
                                  [:fcall, :other,
                                   [:splat, [:lvar, :args]]]]]]],
            "ParseTree"    => s(:defn, :blah,
                                s(:args, :"*args", :"&block"),
                                s(:scope,
                                  s(:block,
                                    s(:call, nil, :other,
                                      s(:arglist,
                                        s(:splat, s(:lvar, :args)),
                                        s(:block_pass, s(:lvar, :block))))))))

  add_tests("block_pass_thingy",
            "Ruby"         => "r.read_body(dest, &block)",
            "RawParseTree" => [:block_pass,
                               [:vcall, :block],
                               [:call, [:vcall, :r], :read_body,
                                [:array, [:vcall, :dest]]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :r, s(:arglist)),
                                :read_body,
                                s(:arglist,
                                  s(:call, nil, :dest, s(:arglist)),
                                  s(:block_pass,
                                    s(:call, nil, :block, s(:arglist))))))

  add_tests("block_stmt_after",
            "Ruby"         => "def f\n  begin\n    b\n  rescue\n    c\n  end\n\n  d\nend",
            "RawParseTree" => [:defn, :f,
                               [:scope,
                                [:block,
                                 [:args],
                                 [:rescue,
                                  [:vcall, :b],
                                  [:resbody, nil, [:vcall, :c]]],
                                 [:vcall, :d]]]],
            "ParseTree"    => s(:defn, :f,
                                s(:args),
                                s(:scope,
                                  s(:block,
                                    s(:rescue,
                                      s(:call, nil, :b, s(:arglist)),
                                      s(:resbody,
                                        s(:array),
                                        s(:call, nil, :c, s(:arglist)))),
                                    s(:call, nil, :d, s(:arglist))))),
            "Ruby2Ruby"    => "def f\n  b rescue c\n  d\nend")

  add_tests("block_stmt_after_mri_verbose_flag",
            "RawParseTree" => [:defn, :f,
                               [:scope,
                                [:block,
                                 [:args],
                                 [:rescue,              # no begin
                                  [:vcall, :b],
                                  [:resbody, nil, [:vcall, :c]]],
                                 [:vcall, :d]]]])

  copy_test_case "block_stmt_after", "Ruby"
  copy_test_case "block_stmt_after", "ParseTree"
  copy_test_case "block_stmt_after", "Ruby2Ruby"

  add_tests("block_stmt_before",
            "Ruby"         => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\nend",
            "RawParseTree" => [:defn, :f,
                               [:scope,
                                [:block,
                                 [:args],
                                 [:vcall, :a],
                                 [:rescue, [:vcall, :b],
                                  [:resbody, nil, [:vcall, :c]]]]]],
            "ParseTree"    => s(:defn, :f,
                                s(:args),
                                s(:scope,
                                  s(:block,
                                    s(:call, nil, :a, s(:arglist)),
                                    s(:rescue, s(:call, nil, :b, s(:arglist)),
                                      s(:resbody,
                                        s(:array),
                                        s(:call, nil, :c, s(:arglist))))))),
            "Ruby2Ruby"    => "def f\n  a\n  b rescue c\nend")

  # oddly... this one doesn't HAVE any differences when verbose... new?
  copy_test_case "block_stmt_before", "Ruby"
  copy_test_case "block_stmt_before", "ParseTree"
  copy_test_case "block_stmt_before", "RawParseTree"
  copy_test_case "block_stmt_before", "Ruby2Ruby"

  add_tests("block_stmt_both",
            "Ruby"         => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\n  d\nend",
            "RawParseTree" => [:defn, :f,
                               [:scope,
                                [:block,
                                 [:args],
                                 [:vcall, :a],
                                 [:rescue,
                                  [:vcall, :b],
                                  [:resbody,
                                   nil,
                                   [:vcall, :c]]],
                                 [:vcall, :d]]]],
            "ParseTree"    => s(:defn, :f, s(:args),
                                s(:scope,
                                  s(:block,
                                    s(:call, nil, :a, s(:arglist)),
                                    s(:rescue,
                                      s(:call, nil, :b, s(:arglist)),
                                      s(:resbody,
                                        s(:array),
                                        s(:call, nil, :c, s(:arglist)))),
                                    s(:call, nil, :d, s(:arglist))))),
            "Ruby2Ruby"    => "def f\n  a\n  b rescue c\n  d\nend")

  add_tests("block_stmt_both_mri_verbose_flag",
            "RawParseTree" => [:defn, :f,
                               [:scope,
                                [:block,
                                 [:args],
                                 [:vcall, :a],
                                 [:rescue,              # no begin
                                  [:vcall, :b],
                                  [:resbody,
                                   nil,
                                   [:vcall, :c]]],
                                 [:vcall, :d]]]])

  copy_test_case "block_stmt_both", "Ruby"
  copy_test_case "block_stmt_both", "ParseTree"
  copy_test_case "block_stmt_both", "Ruby2Ruby"

  add_tests("bmethod",
            "Ruby"         => [Examples, :unsplatted],
            "RawParseTree" => [:defn, :unsplatted,
                               [:bmethod,
                                [:dasgn_curr, :x],
                                [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
            "ParseTree"    => s(:defn, :unsplatted,
                                s(:args, :x),
                                s(:scope,
                                  s(:block,
                                    s(:call,
                                      s(:lvar, :x),
                                      :+,
                                      s(:arglist, s(:lit, 1)))))),
            "Ruby2Ruby"    => "def unsplatted(x)\n  (x + 1)\nend")

  add_tests("bmethod_noargs",
            "Ruby"         => [Examples, :bmethod_noargs],
            "RawParseTree" => [:defn, :bmethod_noargs,
                               [:bmethod,
                                nil,
                                [:call,
                                 [:vcall, :x], :"+", [:array, [:lit, 1]]]]],
            "ParseTree"    => s(:defn, :bmethod_noargs,
                                s(:args),
                                s(:scope,
                                  s(:block,
                                    s(:call,
                                      s(:call, nil, :x, s(:arglist)),
                                      :"+",
                                      s(:arglist, s(:lit, 1)))))),
            "Ruby2Ruby"    => "def bmethod_noargs\n  (x + 1)\nend")

  add_tests("bmethod_splat",
            "Ruby"         => [Examples, :splatted],
            "RawParseTree" => [:defn, :splatted,
                               [:bmethod,
                                [:masgn, nil, [:dasgn_curr, :args], nil],
                                [:block,
                                 [:dasgn_curr, :y,
                                  [:call, [:dvar, :args], :first]],
                                 [:call, [:dvar, :y], :+,
                                  [:array, [:lit, 42]]]]]],
            "ParseTree"    => s(:defn, :splatted,
                                s(:args, :"*args"),
                                s(:scope,
                                  s(:block,
                                    s(:lasgn, :y,
                                      s(:call, s(:lvar, :args), :first,
                                        s(:arglist))),
                                    s(:call, s(:lvar, :y), :+,
                                      s(:arglist, s(:lit, 42)))))),
            "Ruby2Ruby"    => "def splatted(*args)\n  y = args.first\n  (y + 42)\nend")

  add_tests("break",
            "Ruby"         => "loop { break if true }",
            "RawParseTree" => [:iter,
                               [:fcall, :loop], nil,
                               [:if, [:true], [:break], nil]],
            "ParseTree"    => s(:iter,
                                s(:call, nil, :loop, s(:arglist)), nil,
                                s(:if, s(:true), s(:break), nil)))

  add_tests("break_arg",
            "Ruby"         => "loop { break 42 if true }",
            "RawParseTree" => [:iter,
                               [:fcall, :loop], nil,
                               [:if, [:true], [:break, [:lit, 42]], nil]],
            "ParseTree"    => s(:iter,
                                s(:call, nil, :loop, s(:arglist)), nil,
                                s(:if, s(:true), s(:break, s(:lit, 42)), nil)))

  add_tests("call",
            "Ruby"         => "self.method",
            "RawParseTree" => [:call, [:self], :method],
            "ParseTree"    => s(:call, s(:self), :method, s(:arglist)))

  add_tests("call_arglist",
            "Ruby"         => "o.puts(42)",
            "RawParseTree" => [:call, [:vcall, :o], :puts,
                               [:array, [:lit, 42]]],
            "ParseTree"    => s(:call, s(:call, nil, :o, s(:arglist)), :puts,
                                s(:arglist, s(:lit, 42))))

  add_tests("call_arglist_hash",
            "Ruby"         => "o.m(:a => 1, :b => 2)",
            "RawParseTree" => [:call,
                               [:vcall, :o], :m,
                               [:array,
                                [:hash,
                                 [:lit, :a], [:lit, 1],
                                 [:lit, :b], [:lit, 2]]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :o, s(:arglist)), :m,
                                s(:arglist,
                                  s(:hash,
                                    s(:lit, :a), s(:lit, 1),
                                    s(:lit, :b), s(:lit, 2)))))

  add_tests("call_arglist_norm_hash",
            "Ruby"         => "o.m(42, :a => 1, :b => 2)",
            "RawParseTree" => [:call,
                               [:vcall, :o], :m,
                               [:array,
                                [:lit, 42],
                                [:hash,
                                 [:lit, :a], [:lit, 1],
                                 [:lit, :b], [:lit, 2]]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :o, s(:arglist)), :m,
                                s(:arglist,
                                  s(:lit, 42),
                                  s(:hash,
                                    s(:lit, :a), s(:lit, 1),
                                    s(:lit, :b), s(:lit, 2)))))

  add_tests("call_arglist_norm_hash_splat",
            "Ruby"         => "o.m(42, :a => 1, :b => 2, *c)",
            "RawParseTree" => [:call,
                               [:vcall, :o], :m,
                               [:argscat,
                                [:array,
                                 [:lit, 42],
                                 [:hash,
                                  [:lit, :a], [:lit, 1],
                                  [:lit, :b], [:lit, 2]]],
                                [:vcall, :c]]],
            "ParseTree"    => s(:call,
                                s(:call, nil, :o, s(:arglist)), :m,
                                s(:arglist,
                                  s(:lit, 42),
                                  s(:hash,
                                    s(:lit, :a), s(:lit, 1),
                                    s(:lit, :b), s(:lit, 2)),
                                  s(:splat, s(:call, nil, :c, s(:arglist))))))

  add_tests("call_arglist_space",
            "Ruby"         => "a (1,2,3)",
            "RawParseTree" => [:fcall, :a,
                               [:array, [:lit, 1], [:lit, 2], [:lit, 3]]],
            "ParseTree"    => s(:call, nil, :a,
                                s(:arglist,
                                  s(:lit, 1), s(:lit, 2), s(:lit, 3))),
            "Ruby2Ruby"    => "a(1, 2, 3)")

  add_tests("call_command",
            "Ruby"         => "1.b(c)",
            "RawParseTree" => [:call, [:lit, 1], :b, [:array, [:vcall, :c]]],
            "ParseTree"    => s(:call,
                                s(:lit, 1),
                                :b,
                                s(:arglist, s(:call, nil, :c, s(:arglist)))))

  add_tests("call_expr",
            "Ruby"         => "(v = (1 + 1)).zero?",
            "RawParseTree" => [:call,
                               [:lasgn, :v,
                                [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
                               :zero?],
            "ParseTree"    => s(:call,
                                s(:lasgn, :v,
                                  s(:call, s(:lit, 1), :+,
                                    s(:arglist, s(:lit, 1)))),
                                :zero?, s(:arglist)))

  add_tests("call_index",
            "Ruby"         => "a = []\na[42]\n",
            "RawParseTree" => [:block,
                               [:lasgn, :a, [:zarray]],
                               [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :a, s(:array)),
                                s(:call, s(:lvar, :a), :[],
                                  s(:arglist, s(:lit, 42)))))

  add_tests("call_index_no_args",
            "Ruby"         => "a[]",
            "RawParseTree" => [:call, [:vcall, :a], :[]],
            "ParseTree"    => s(:call, s(:call, nil, :a, s(:arglist)),
                                :[], s(:arglist)))

  add_tests("call_index_space",
            "Ruby"         => "a = []\na [42]\n",
            "RawParseTree" => [:block,
                               [:lasgn, :a, [:zarray]],
                               [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :a, s(:array)),
                                s(:call, s(:lvar, :a), :[],
                                  s(:arglist, s(:lit, 42)))),
            "Ruby2Ruby"    => "a = []\na[42]\n")

  add_tests("call_unary_neg",
            "Ruby"         => "-2**31",
            "RawParseTree" => [:call,
                               [:call, [:lit, 2], :**, [:array, [:lit, 31]]],
                               :-@],
            "ParseTree"    => s(:call,
                                s(:call,
                                  s(:lit, 2),
                                  :**,
                                  s(:arglist, s(:lit, 31))),
                                :-@, s(:arglist)),
            "Ruby2Ruby"    => "-(2 ** 31)")

  add_tests("case",
            "Ruby"         => "var = 2\nresult = \"\"\ncase var\nwhen 1 then\n  puts(\"something\")\n  result = \"red\"\nwhen 2, 3 then\n  result = \"yellow\"\nwhen 4 then\n  # do nothing\nelse\n  result = \"green\"\nend\ncase result\nwhen \"red\" then\n  var = 1\nwhen \"yellow\" then\n  var = 2\nwhen \"green\" then\n  var = 3\nelse\n  # do nothing\nend\n",
            "RawParseTree" => [:block,
                               [:lasgn, :var, [:lit, 2]],
                               [:lasgn, :result, [:str, ""]],
                               [:case,
                                [:lvar, :var],
                                [:when,
                                 [:array, [:lit, 1]],
                                 [:block,
                                  [:fcall, :puts,
                                   [:array, [:str, "something"]]],
                                  [:lasgn, :result, [:str, "red"]]]],
                                [:when,
                                 [:array, [:lit, 2], [:lit, 3]],
                                 [:lasgn, :result, [:str, "yellow"]]],
                                [:when, [:array, [:lit, 4]], nil],
                                [:lasgn, :result, [:str, "green"]]],
                               [:case,
                                [:lvar, :result],
                                [:when, [:array, [:str, "red"]],
                                 [:lasgn, :var, [:lit, 1]]],
                                [:when, [:array, [:str, "yellow"]],
                                 [:lasgn, :var, [:lit, 2]]],
                                [:when, [:array, [:str, "green"]],
                                 [:lasgn, :var, [:lit, 3]]],
                                nil]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :var, s(:lit, 2)),
                                s(:lasgn, :result, s(:str, "")),
                                s(:case,
                                  s(:lvar, :var),
                                  s(:when,
                                    s(:array, s(:lit, 1)),
                                    s(:block,
                                      s(:call, nil, :puts,
                                        s(:arglist, s(:str, "something"))),
                                      s(:lasgn, :result, s(:str, "red")))),
                                  s(:when,
                                    s(:array, s(:lit, 2), s(:lit, 3)),
                                    s(:lasgn, :result, s(:str, "yellow"))),
                                  s(:when, s(:array, s(:lit, 4)), nil),
                                  s(:lasgn, :result, s(:str, "green"))),
                                s(:case,
                                  s(:lvar, :result),
                                  s(:when, s(:array, s(:str, "red")),
                                    s(:lasgn, :var, s(:lit, 1))),
                                  s(:when, s(:array, s(:str, "yellow")),
                                    s(:lasgn, :var, s(:lit, 2))),
                                  s(:when, s(:array, s(:str, "green")),
                                    s(:lasgn, :var, s(:lit, 3))),
                                  nil)))

  add_tests("case_nested",
            "Ruby"         => "var1 = 1\nvar2 = 2\nresult = nil\ncase var1\nwhen 1 then\n  case var2\n  when 1 then\n    result = 1\n  when 2 then\n    result = 2\n  else\n    result = 3\n  end\nwhen 2 then\n  case var2\n  when 1 then\n    result = 4\n  when 2 then\n    result = 5\n  else\n    result = 6\n  end\nelse\n  result = 7\nend\n",
            "RawParseTree" => [:block,
                               [:lasgn, :var1, [:lit, 1]],
                               [:lasgn, :var2, [:lit, 2]],
                               [:lasgn, :result, [:nil]],
                               [:case,
                                [:lvar, :var1],
                                [:when, [:array, [:lit, 1]],
                                 [:case,
                                  [:lvar, :var2],
                                  [:when, [:array, [:lit, 1]],
                                   [:lasgn, :result, [:lit, 1]]],
                                  [:when, [:array, [:lit, 2]],
                                   [:lasgn, :result, [:lit, 2]]],
                                  [:lasgn, :result, [:lit, 3]]]],
                                [:when, [:array, [:lit, 2]],
                                 [:case,
                                  [:lvar, :var2],
                                  [:when, [:array, [:lit, 1]],
                                   [:lasgn, :result, [:lit, 4]]],
                                  [:when, [:array, [:lit, 2]],
                                   [:lasgn, :result, [:lit, 5]]],
                                  [:lasgn, :result, [:lit, 6]]]],
                                [:lasgn, :result, [:lit, 7]]]],
            "ParseTree"    => s(:block,
                                s(:lasgn, :var1, s(:lit, 1)),
                                s(:lasgn, :var2, s(:lit, 2)),
                                s(:lasgn, :result, s(:nil)),
                                s(:case,
                                  s(:lvar, :var1),
                                  s(:when, s(:array, s(:lit, 1)),
                                    s(:case,
                                      s(:lvar, :var2),
                                      s(:when, s(:array, s(:lit, 1)),
                                        s(:lasgn, :result, s(:lit, 1))),
                                      s(:when, s(:array, s(:lit, 2)),
                                        s(:lasgn, :result, s(:lit, 2))),
                                      s(:lasgn, :result, s(:lit, 3)))),
                                  s(:when, s(:array, s(:lit, 2)),
                                    s(:case,
                                      s(:lvar, :var2),
                                      s(:when, s(:array, s(:lit, 1)),
                                        s(:lasgn, :result, s(:lit, 4))),
                                      s(:when, s(:array, s(:lit, 2)),
                                        s(:lasgn, :result, s(:lit, 5))),
                                      s(:lasgn, :result, s(:lit, 6)))),
                                  s(:lasgn, :result, s(:lit, 7)))))

  add_tests("case_nested_inner_no_expr",
            "Ruby"         => "case a\nwhen b then\n  case\n  when (d and e) then\n    f\n  else\n    # do nothing\n  end\nelse\n  # do nothing\nend",
            "RawParseTree" => [:case, [:vcall, :a],
                               [:when, [:array, [:vcall, :b]],
                                [:case, nil,
                                 [:when,
                                  [:array, [:and, [:vcall, :d], [:vcall, :e]]],
                                  [:vcall, :f]],
                                 nil]],
                               nil],
            "ParseTree"    => s(:case, s(:call, nil, :a, s(:arglist)),
                                s(:when,
                                  s(:array, s(:call, nil, :b, s(:arglist))),
                                  s(:case, nil,
                                    s(:when,
                                      s(:array,
                                        s(:and,
                                          s(:call, nil, :d, s(:arglist)),
                                          s(:call, nil, :e, s(:arglist)))),
                                      s(:call, nil, :f, s(:arglist))),
                                    nil)),
                                nil))

  add_tests("case_no_expr",
            "Ruby"         => "case\nwhen (a == 1) then\n  :a\nwhen (a == 2) then\n  :b\nelse\n  :c\nend",
            "RawParseTree" => [:case, nil,
                               [:when,
                                [:array,
                                 [:call, [:vcall, :a], :==,
                                  [:array, [:lit, 1]]]],
                                [:lit, :a]],
                               [:when,
                                [:array,
                                 [:call, [:vcall, :a], :==,
                                  [:array, [:lit, 2]]]],
                                [:lit, :b]],
                               [:lit, :c]],
            "ParseTree"    => s(:case, nil,
                                s(:when,
                                  s(:array,
                                    s(:call,
                                      s(:call, nil, :a, s(:arglist)),
                                      :==,
                                      s(:arglist, s(:lit, 1)))),
                                  s(:lit, :a)),
        …