brakeman 4.3.1 → 5.0.0

data/bundle/ruby/2.5.0/gems/sexp_processor-4.11.0/Manifest.txt

@@ -1,14 +0,0 @@
-History.rdoc
-Manifest.txt
-README.rdoc
-Rakefile
-lib/composite_sexp_processor.rb
-lib/pt_testcase.rb
-lib/sexp.rb
-lib/sexp_processor.rb
-lib/strict_sexp.rb
-lib/unique.rb
-test/test_composite_sexp_processor.rb
-test/test_environment.rb
-test/test_sexp.rb
-test/test_sexp_processor.rb

data/bundle/ruby/2.5.0/gems/sexp_processor-4.11.0/Rakefile

@@ -1,17 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-
-Hoe.plugin :seattlerb
-Hoe.plugin :rdoc
-
-Hoe.add_include_dirs("../../ruby_parser/dev/lib")
-
-Hoe.spec 'sexp_processor' do
-  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
-
-  license "MIT"
-end
-
-# vim: syntax=ruby

data/bundle/ruby/2.5.0/gems/sexp_processor-4.11.0/lib/pt_testcase.rb

@@ -1,3130 +0,0 @@
-# encoding: US-ASCII
-
-$TESTING = true
-# :stopdoc:
-
-require "minitest/test"
-require "sexp_processor" # for deep_clone
-
-# key:
-# wwtt = what were they thinking?
-
-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::Test
-  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.add_18tests name, hash
-    add_tests "#{name}__18", hash
-  end
-
-  def self.add_19tests name, hash
-    add_tests "#{name}__19_20_21_22_23_24_25", hash # HACK?
-  end
-
-  def self.add_19edgecases ruby, sexp, cases
-    cases.each do |name, code|
-      add_19tests name, "Ruby" => code, "ParseTree" => sexp, "Ruby2Ruby" => ruby
-    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
-
-  VER_RE = "(1[89]|2[012345])"
-
-  def self.generate_test klass, node, data, input_name, output_name
-    klass.send :define_method, "test_#{node}" do
-      flunk "Processor is nil" if processor.nil?
-
-      tversions = node[/(?:_#{VER_RE})+$/]
-      if tversions then
-        cversion = self.class.name[/#{VER_RE}/]
-
-        assert true # shut up prove_it!
-
-        # can't push this up because it may be generating into an
-        # abstract test class and the actual subclass is versioned.
-        return "version specific test" unless tversions.include? cversion if cversion
-      end
-
-      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.sexp_type == :defx
-        _, input, extra_input = *input if
-          Array === input and input.sexp_type == :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 cases 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 ParseTree)
-
-  @@testcases = Hash.new { |h,k| h[k] = {} }
-
-  ###
-  # 1.8 specific tests
-
-  add_18tests("call_arglist_norm_hash_splat",
-              "Ruby"         => "o.m(42, :a => 1, :b => 2, *c)",
-              "ParseTree"    => s(:call,
-                                  s(:call, nil, :o), :m,
-                                  s(:lit, 42),
-                                  s(:hash,
-                                    s(:lit, :a), s(:lit, 1),
-                                    s(:lit, :b), s(:lit, 2)),
-                                  s(:splat, s(:call, nil, :c))))
-
-  add_18tests("call_arglist_space",
-              "Ruby"         => "a (1,2,3)",
-              "ParseTree"    => s(:call, nil, :a,
-                                  s(:lit, 1), s(:lit, 2), s(:lit, 3)),
-              "Ruby2Ruby"    => "a(1, 2, 3)")
-
-  add_18tests("fcall_arglist_norm_hash_splat",
-              "Ruby"         => "m(42, :a => 1, :b => 2, *c)",
-              "ParseTree"    => s(:call, nil, :m,
-                                  s(:lit, 42),
-                                  s(:hash,
-                                    s(:lit, :a), s(:lit, 1),
-                                    s(:lit, :b), s(:lit, 2)),
-                                  s(:splat, s(:call, nil, :c))))
-
-  add_18tests("if_args_no_space_symbol",
-              "Ruby"       => "x if y:z",
-              "ParseTree"  => s(:if,
-                                s(:call, nil, :y,  s(:lit, :z)),
-                                s(:call, nil, :x),
-                                nil),
-              "Ruby2Ruby"  => "x if y(:z)")
-
-  add_18tests("if_post_not",
-              "Ruby"         => "a if not b",
-              "ParseTree"    => s(:if, s(:call, nil, :b), nil,
-                                  s(:call, nil, :a)),
-              "Ruby2Ruby"    => "a unless b")
-
-  add_18tests("if_pre_not",
-              "Ruby"         => "if not b then a end",
-              "ParseTree"    => s(:if, s(:call, nil, :b), nil,
-                                  s(:call, nil, :a)),
-              "Ruby2Ruby"    => "a unless b")
-
-  add_18tests("iter_args_ivar",
-              "Ruby"         => "a { |@a| 42 }",
-              "ParseTree"    => s(:iter,
-                                  s(:call, nil, :a),
-                                  s(:args, :@a),
-                                  s(:lit, 42)))
-
-  add_18tests("iter_masgn_args_ivar",
-              "Ruby"         => "a { |a, @b| 42 }",
-              "ParseTree"    => s(:iter,
-                                  s(:call, nil, :a),
-                                  s(:args, :a, :@b),
-                                  s(:lit, 42)))
-
-  add_18tests("not",
-              "Ruby"         => "(not true)",
-              "ParseTree"    => s(:not, s(:true)))
-
-  add_18tests("str_question_control",
-              "Ruby"         => '?\M-\C-a',
-              "ParseTree"    => s(:lit, 129),
-              "Ruby2Ruby"    => "129")
-
-  add_18tests("str_question_escape",
-              "Ruby"         => '?\n',
-              "ParseTree"    => s(:lit, 10),
-              "Ruby2Ruby"    => "10")
-
-  add_18tests("str_question_literal",
-              "Ruby"         => "?a",
-              "ParseTree"    => s(:lit, 97),
-              "Ruby2Ruby"    => "97")
-
-  add_18tests("unless_post_not",
-              "Ruby"         => "a unless not b",
-              "ParseTree"    => s(:if, s(:call, nil, :b),
-                                  s(:call, nil, :a), nil),
-              "Ruby2Ruby"    => "a if b")
-
-  add_18tests("unless_pre_not",
-              "Ruby"         => "unless not b then a end",
-              "ParseTree"    => s(:if, s(:call, nil, :b),
-                                  s(:call, nil, :a), nil),
-              "Ruby2Ruby"    => "a if b")
-
-  add_18tests("until_post_not",
-              "Ruby"         => "begin\n  (1 + 1)\nend until not true",
-              "ParseTree"    => s(:while, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
-              "Ruby2Ruby"    => "begin\n  (1 + 1)\nend while true")
-
-  add_18tests("until_pre_not",
-              "Ruby"         => "until not true do\n  (1 + 1)\nend",
-              "ParseTree"    => s(:while, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "while true do\n  (1 + 1)\nend")
-
-  add_18tests("until_pre_not_mod",
-              "Ruby"         => "(1 + 1) until not true",
-              "ParseTree"    => s(:while, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "while true do\n  (1 + 1)\nend")
-
-  add_18tests("while_post_not",
-              "Ruby"         => "begin\n  (1 + 1)\nend while not true",
-              "ParseTree"    => s(:until, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
-              "Ruby2Ruby"    => "begin\n  (1 + 1)\nend until true")
-
-  add_18tests("while_pre_not",
-              "Ruby"         => "while not true do\n  (1 + 1)\nend",
-              "ParseTree"    => s(:until, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "until true do\n  (1 + 1)\nend")
-
-  add_18tests("while_pre_not_mod",
-              "Ruby"         => "(1 + 1) while not true",
-              "ParseTree"    => s(:until, s(:true),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "until true do\n  (1 + 1)\nend") # FIX
-
-  ###
-  # 1.9 specific tests
-
-  add_19edgecases("lambda { || (x + 1) }",
-                  s(:iter,
-                    s(:call, nil, :lambda),
-                    s(:args),
-                    s(:call, s(:call, nil, :x), :+, s(:lit, 1))),
-                  "stabby_args"                   => "->() { (x + 1) }",
-                  "stabby_args_doend"             => "->() do (x + 1) end")
-
-  add_19edgecases("lambda { (x + 1) }",
-                  s(:iter,
-                    s(:call, nil, :lambda),
-                    0,
-                    s(:call, s(:call, nil, :x), :+, s(:lit, 1))),
-                  "stabby_args_0_no_parens"       => "-> { (x + 1) }",
-                  "stabby_args_0_no_parens_doend" => "-> do (x + 1) end",
-                  "stabby_args_0_spacebar_broken" => "->{x+1}") # I hate you
-
-  add_19edgecases("lambda { |x, y| (x + y) }",
-                  s(:iter,
-                    s(:call, nil, :lambda),
-                    s(:args, :x, :y),
-                    s(:call, s(:lvar, :x), :+, s(:lvar, :y))),
-                  "stabby_args_2"                 => "->(x, y) { (x + y) }",
-                  "stabby_args_2_doend"           => "->(x, y) do (x + y) end",
-                  "stabby_args_2_no_parens"       => "-> x, y { (x + y) }",
-                  "stabby_args_2_no_parens_doend" => "-> x, y do (x + y) end")
-
-  add_19edgecases("lambda { |x| (x + 1) }",
-                  s(:iter,
-                    s(:call, nil, :lambda),
-                    s(:args, :x),
-                    s(:call, s(:lvar, :x), :+, s(:lit, 1))),
-                  "stabby_args_1"                 => "->(x) { (x + 1) }",
-                  "stabby_args_1_doend"           => "->(x) do (x + 1) end",
-                  "stabby_args_1_no_parens"       => "-> x { (x + 1) }",
-                  "stabby_args_1_no_parens_doend" => "-> x do (x + 1) end")
-
-  add_19tests("array_bare_hash",
-              "Ruby"         => "[:a, :b => :c]",
-              "ParseTree"    => s(:array,
-                                  s(:lit, :a),
-                                  s(:hash,
-                                    s(:lit, :b),
-                                    s(:lit, :c))),
-              "Ruby2Ruby"    => "[:a, { :b => :c }]")
-
-  add_19tests("array_bare_hash_labels",
-              "Ruby"         => "[:a, b: :c]",
-              "ParseTree"    => s(:array,
-                                  s(:lit, :a),
-                                  s(:hash,
-                                    s(:lit, :b),
-                                    s(:lit, :c))),
-              "Ruby2Ruby"    => "[:a, { :b => :c }]")
-
-  add_19tests("call_arglist_norm_hash_colons",
-              "Ruby"         => "o.m(42, a: 1, b: 2)",
-              "ParseTree"    => s(:call,
-                                  s(:call, nil, :o),
-                                  :m,
-                                  s(:lit, 42),
-                                  s(:hash,
-                                    s(:lit, :a), s(:lit, 1),
-                                    s(:lit, :b), s(:lit, 2))),
-              "Ruby2Ruby"    => "o.m(42, :a => 1, :b => 2)")
-
-  add_19tests("call_arglist_trailing_comma",
-              "Ruby"         => "a(1,2,3,)",
-              "ParseTree"    => s(:call,
-                                  nil,
-                                  :a,
-                                  s(:lit, 1), s(:lit, 2), s(:lit, 3)),
-              "Ruby2Ruby"    => "a(1, 2, 3)")
-
-  add_19tests("call_bang",
-              "Ruby"         => "!a",
-              "ParseTree"    => s(:call,
-                                  s(:call, nil, :a),
-                                  :"!"),
-              "Ruby2Ruby"    => "(not a)")
-
-  add_19tests("call_bang_empty",
-              "Ruby"         => "! ()",
-              "ParseTree"    => s(:call, s(:nil), :"!"),
-              "Ruby2Ruby"    => "(not nil)")
-
-  add_19tests("call_fonz",
-              "Ruby"         => "a.()",
-              "ParseTree"    => s(:call, s(:call, nil, :a), :call),
-              "Ruby2Ruby"    => "a.call")
-
-  add_19tests("call_fonz_cm",
-              "Ruby"         => "a::()",
-              "ParseTree"    => s(:call, s(:call, nil, :a), :call),
-              "Ruby2Ruby"    => "a.call")
-
-  add_19tests("call_not",
-              "Ruby"      => "not (42)",
-              "ParseTree" => s(:call, s(:lit, 42), :"!"),
-              "Ruby2Ruby" => "(not 42)")
-
-  # add_19tests("call_not_empty",
-  #             "Ruby"      => "not ()",
-  #             "ParseTree" => s(:call, s(:lit, 42), :"!"))
-
-  add_19tests("call_not_equal",
-            "Ruby"         => "a != b",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :a),
-                                :"!=",
-                                s(:call, nil, :b)),
-            "Ruby2Ruby"    => "(a != b)")
-
-  add_19tests("call_splat_mid",
-              "Ruby"      => "def f(a = nil, *b, c)\n  # do nothing\nend",
-              "ParseTree" => s(:defn, :f,
-                               s(:args, s(:lasgn, :a, s(:nil)), :"*b", :c),
-                               s(:nil)))
-
-  add_19tests("defn_args_mand_opt_mand",
-              "Ruby"      => "def f(mand1, opt = 42, mand2)\n  # do nothing\nend",
-              "ParseTree" => s(:defn, :f,
-                               s(:args, :mand1, s(:lasgn, :opt, s(:lit, 42)), :mand2),
-                               s(:nil)))
-
-  add_19tests("defn_args_mand_opt_splat_mand",
-              "Ruby"      => "def f(mand1, opt = 42, *rest, mand2)\n  # do nothing\nend",
-              "ParseTree" => s(:defn, :f,
-                               s(:args, :mand1, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :mand2),
-                               s(:nil)))
-
-  add_19tests("defn_args_opt_mand",
-              "Ruby"      => "def f(opt = 42, mand)\n  # do nothing\nend",
-              "ParseTree" => s(:defn, :f,
-                               s(:args, s(:lasgn, :opt, s(:lit, 42)), :mand),
-                               s(:nil)))
-
-  add_19tests("defn_args_opt_splat_mand",
-              "Ruby"      => "def f(opt = 42, *rest, mand)\n  # do nothing\nend",
-              "ParseTree" => s(:defn, :f,
-                               s(:args, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :mand),
-                               s(:nil)))
-
-  add_19tests("defn_args_splat_mand",
-              "Ruby"         => "def f(*rest, mand)\n  # do nothing\nend",
-              "ParseTree"    => s(:defn, :f,
-                                  s(:args, :"*rest", :mand),
-                                  s(:nil)))
-
-  add_19tests("defn_args_splat_middle",
-            "Ruby"         => "def f(first, *middle, last)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :first, :"*middle", :last),
-                                s(:nil)))
-
-  add_19tests("fcall_arglist_hash_colons",
-              "Ruby"         => "m(a: 1, b: 2)",
-              "ParseTree"    => s(:call, nil, :m,
-                                  s(:hash,
-                                    s(:lit, :a), s(:lit, 1),
-                                    s(:lit, :b), s(:lit, 2))),
-              "Ruby2Ruby"    => "m(:a => 1, :b => 2)")
-
-  add_19tests("hash_new",
-              "Ruby"         => "{ a: 1, b: 2 }",
-              "ParseTree"    => s(:hash,
-                                  s(:lit, :a), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2)),
-              "Ruby2Ruby"    => "{ :a => 1, :b => 2 }")
-
-  add_19tests("hash_new_no_space",
-              "Ruby"         => "{a:1,b:2}",
-              "ParseTree"    => s(:hash,
-                                  s(:lit, :a), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2)),
-              "Ruby2Ruby"    => "{ :a => 1, :b => 2 }")
-
-  add_19tests("hash_new_with_keyword",
-              "Ruby"         => "{ true: 1, b: 2 }",
-              "ParseTree"    => s(:hash,
-                                  s(:lit, :true), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2)),
-              "Ruby2Ruby"    => "{ :true => 1, :b => 2 }")
-
-  add_19tests("if_post_not",
-              "Ruby"         => "a if not b",
-              "ParseTree"    => s(:if, s(:call, s(:call, nil, :b), :"!"),
-                                  s(:call, nil, :a),
-                                  nil),
-              "Ruby2Ruby"    => "a unless b")
-
-  add_19tests("if_pre_not",
-              "Ruby"         => "if not b then a end",
-              "ParseTree"    => s(:if, s(:call, s(:call, nil, :b), :"!"),
-                                  s(:call, nil, :a),
-                                  nil),
-              "Ruby2Ruby"    => "a unless b")
-
-  add_19tests("label_in_bare_hash_in_array_in_ternary",
-              "Ruby"         => "1 ? [:a, b: 2] : 1",
-              "ParseTree"    => s(:if, s(:lit, 1),
-                                  s(:array,
-                                    s(:lit, :a),
-                                    s(:hash, s(:lit, :b), s(:lit, 2))),
-                                  s(:lit, 1)),
-              "Ruby2Ruby"    => "1 ? ([:a, { :b => 2 }]) : (1)")
-
-  add_19tests("label_in_callargs_in_ternary",
-              "Ruby"         => "1 ? m(a: 2) : 1",
-              "ParseTree"    => s(:if, s(:lit, 1),
-                                  s(:call, nil, :m,
-                                    s(:hash, s(:lit, :a), s(:lit, 2))),
-                                  s(:lit, 1)),
-              "Ruby2Ruby"    => "1 ? (m(:a => 2)) : (1)")
-
-  add_19tests("not",
-              "Ruby"         => "(not true)",
-              "ParseTree"    => s(:call, s(:true), :"!"))
-
-  add_19tests("splat_fcall_middle",
-              "Ruby"         => "meth(1, *[2], 3)",
-              "ParseTree"    => s(:call,
-                                  nil,
-                                  :meth,
-                                  s(:lit, 1),
-                                  s(:splat, s(:array, s(:lit, 2))),
-                                  s(:lit, 3)))
-
-  add_19tests("str_question_control",
-              "Ruby"         => '?\M-\C-a',
-              "ParseTree"    => s(:str, "\x81"),
-              "Ruby2Ruby"    => "\"\\x81\"")
-
-  add_19tests("str_question_escape",
-              "Ruby"         => '?\n',
-              "ParseTree"    => s(:str, "\n"),
-              "Ruby2Ruby"    => "\"\\n\"")
-
-  add_19tests("str_question_literal",
-              "Ruby"         => "?a",
-              "ParseTree"    => s(:str, "a"),
-              "Ruby2Ruby"    => '"a"')
-
-  add_19tests("unless_post_not",
-              "Ruby"         => "a unless not b",
-              "ParseTree"    => s(:if, s(:call, s(:call, nil, :b), :"!"),
-                                  nil,
-                                  s(:call, nil, :a)),
-              "Ruby2Ruby"    => "a if b")
-
-  add_19tests("unless_pre_not",
-              "Ruby"         => "unless not b then a end",
-              "ParseTree"    => s(:if, s(:call, s(:call, nil, :b), :"!"),
-                                  nil,
-                                  s(:call, nil, :a)),
-              "Ruby2Ruby"    => "a if b")
-
-  add_19tests("until_post_not",
-              "Ruby"         => "begin\n  (1 + 1)\nend until not true",
-              "ParseTree"    => s(:until, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
-              "Ruby2Ruby"    => "begin\n  (1 + 1)\nend while true")
-
-  add_19tests("until_pre_not",
-              "Ruby"         => "until not true do\n  (1 + 1)\nend",
-              "ParseTree"    => s(:until, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "while true do\n  (1 + 1)\nend")
-
-  add_19tests("until_pre_not_mod",
-              "Ruby"         => "(1 + 1) until not true",
-              "ParseTree"    => s(:until, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "while true do\n  (1 + 1)\nend")
-
-  add_19tests("while_post_not",
-              "Ruby"         => "begin\n  (1 + 1)\nend while not true",
-              "ParseTree"    => s(:while, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), false),
-              "Ruby2Ruby"    => "begin\n  (1 + 1)\nend until true")
-
-  add_19tests("while_pre_not",
-              "Ruby"         => "while not true do\n  (1 + 1)\nend",
-              "ParseTree"    => s(:while, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "until true do\n  (1 + 1)\nend")
-
-  add_19tests("while_pre_not_mod",
-              "Ruby"         => "(1 + 1) while not true",
-              "ParseTree"    => s(:while, s(:call, s(:true), :"!"),
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-              "Ruby2Ruby"    => "until true do\n  (1 + 1)\nend") # FIX
-
-  ###
-  # Shared tests:
-
-  add_tests("alias",
-            "Ruby"         => "class X\n  alias :y :x\nend",
-            "ParseTree"    => s(:class, :X, nil,
-                                s(:alias, s(:lit, :y), s(:lit, :x))))
-
-  add_tests("alias_ugh",
-            "Ruby"         => "class X\n  alias y x\nend",
-            "ParseTree"    => s(:class, :X, nil,
-                                s(:alias, s(:lit, :y), s(:lit, :x))),
-            "Ruby2Ruby"    => "class X\n  alias :y :x\nend")
-
-  add_tests("and",
-            "Ruby"         => "a and b",
-            "ParseTree"    => s(:and,
-                                s(:call, nil, :a),
-                                s(:call, nil, :b)))
-
-  add_tests("argscat_inside",
-            "Ruby"         => "a = [b, *c]",
-            "ParseTree"    => s(:lasgn, :a,
-                                s(:array,
-                                  s(:call, nil, :b),
-                                  s(:splat, s(:call, nil, :c)))))
-
-  add_tests("argscat_svalue",
-            "Ruby"         => "a = b, c, *d",
-            "ParseTree"    => s(:lasgn, :a,
-                                s(:svalue,
-                                  s(:array,
-                                    s(:call, nil, :b),
-                                    s(:call, nil, :c),
-                                    s(:splat,
-                                      s(:call, nil, :d))))))
-
-  add_tests("argspush",
-            "Ruby"         => "a[*b] = c",
-            "ParseTree"    => s(:attrasgn,
-                                s(:call, nil, :a),
-                                :[]=,
-                                s(:splat,
-                                  s(:call, nil, :b)),
-                                s(:call, nil, :c)))
-
-  add_tests("array",
-            "Ruby"         => "[1, :b, \"c\"]",
-            "ParseTree"    => s(:array, s(:lit, 1), s(:lit, :b), s(:str, "c")))
-
-  add_tests("array_pct_W",
-            "Ruby"         => "%W[a b 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]",
-            "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]",
-            "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]",
-            "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",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :y, s(:lit, 0)),
-                                s(:attrasgn,
-                                  s(:lit, 42), :method=, s(:lvar, :y))))
-
-  add_tests("attrasgn_index_equals",
-            "Ruby"         => "a[42] = 24",
-            "ParseTree"    => s(:attrasgn,
-                                s(:call, nil, :a),
-                                :[]=,
-                                s(:lit, 42), s(:lit, 24)))
-
-  add_tests("attrasgn_index_equals_space",
-            "Ruby"         => "a = []; a [42] = 24",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :a, s(:array)),
-                                s(:attrasgn, s(:lvar, :a), :[]=,
-                                  s(:lit, 42), s(:lit, 24))),
-            "Ruby2Ruby"    => "a = []\na[42] = 24\n")
-
-  add_tests("back_ref",
-            "Ruby"         => "[$&, $`, $', $+]",
-            "ParseTree"    => s(:array,
-                                s(:back_ref, :&),
-                                s(:back_ref, :"`"),
-                                s(:back_ref, :"'"),
-                                s(:back_ref, :+)))
-
-  add_tests("begin",
-            "Ruby"         => "begin\n  (1 + 1)\nend",
-            "ParseTree"    => s(:call, s(:lit, 1), :+, s(:lit, 1)),
-            "Ruby2Ruby"    => "(1 + 1)")
-
-  add_tests("begin_def",
-            "Ruby"         => "def m\n  begin\n\n  end\nend",
-            "ParseTree"    => s(:defn, :m, s(:args), 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",
-            "ParseTree"    => s(:ensure,
-                                s(:rescue,
-                                  s(:call, nil, :a),
-                                  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",
-            "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",
-            "ParseTree"    => s(:block,
-                                s(:rescue,
-                                  s(:call, nil, :a),
-                                  s(:resbody,
-                                    s(:array, s(:lasgn, :mes, s(:gvar, :$!))),
-                                    nil)),
-                                s(:rescue,
-                                  s(:call, nil, :b),
-                                  s(:resbody,
-                                    s(:array,
-                                      s(:lasgn, :mes, s(:gvar, :$!))),
-                                    nil))))
-  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",
-            "ParseTree" => s(:defs, s(:self), :setup,
-                             s(:args, :ctx),
-                             s(:lasgn, :bind, s(:call, nil, :allocate)),
-                             s(:attrasgn,
-                               s(:lvar, :bind), :context=, s(:lvar, :ctx)),
-                             s(:return, s(:lvar, :bind))))
-
-  add_tests("block_lasgn",
-            "Ruby"         => "x = (y = 1\n(y + 2))",
-            "ParseTree"    => s(:lasgn, :x,
-                                s(:block,
-                                  s(:lasgn, :y, s(:lit, 1)),
-                                  s(:call, s(:lvar, :y), :+, 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",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a, s(:call, nil, :b)),
-                                0,
-                                s(:if,
-                                  s(:call, nil, :b),
-                                  s(:true),
-                                  s(:block,
-                                    s(:lasgn, :c, s(:false)),
-                                    s(:iter,
-                                      s(:call, nil, :d),
-                                      s(:args, :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",
-            "ParseTree"    => s(:defn, :blah, s(:args, :"*args", :"&block"),
-                                s(:call, nil, :other,
-                                  s(:lit, 42),
-                                  s(:splat, s(:lvar, :args)),
-                                  s(:block_pass, s(:lvar, :block)))))
-
-  add_tests("block_pass_call_0",
-            "Ruby"         => "a.b(&c)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :a),
-                                :b,
-                                s(:block_pass, s(:call, nil, :c))))
-
-  add_tests("block_pass_call_1",
-            "Ruby"         => "a.b(4, &c)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :a),
-                                :b,
-                                s(:lit, 4),
-                                s(:block_pass, s(:call, nil, :c))))
-
-  add_tests("block_pass_call_n",
-            "Ruby"         => "a.b(1, 2, 3, &c)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :a),
-                                :b,
-                                s(:lit, 1), s(:lit, 2), s(:lit, 3),
-                                s(:block_pass, s(:call, nil, :c))))
-
-  add_tests("block_pass_fcall_0",
-            "Ruby"         => "a(&b)",
-            "ParseTree"    => s(:call, nil, :a,
-                                s(:block_pass, s(:call, nil, :b))))
-
-  add_tests("block_pass_fcall_1",
-            "Ruby"         => "a(4, &b)",
-            "ParseTree"    => s(:call, nil, :a,
-                                s(:lit, 4),
-                                s(:block_pass, s(:call, nil, :b))))
-
-  add_tests("block_pass_fcall_n",
-            "Ruby"         => "a(1, 2, 3, &b)",
-            "ParseTree"    => s(:call, nil, :a,
-                                s(:lit, 1), s(:lit, 2), s(:lit, 3),
-                                s(:block_pass, s(:call, nil, :b))))
-
-  add_tests("block_pass_omgwtf",
-            "Ruby"         => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
-            "ParseTree"    => s(:call, nil, :define_attr_method,
-                                s(:lit, :x),
-                                s(:lit, :sequence_name),
-                                s(:block_pass,
-                                  s(:iter,
-                                    s(:call, s(:const, :Proc), :new),
-                                    s(:args, :"*args"),
-                                    s(:nil)))))
-
-  add_tests("block_pass_splat",
-            "Ruby"         => "def blah(*args, &block)\n  other(*args, &block)\nend",
-            "ParseTree"    => s(:defn, :blah,
-                                s(:args, :"*args", :"&block"),
-                                s(:call, nil, :other,
-                                  s(:splat, s(:lvar, :args)),
-                                  s(:block_pass, s(:lvar, :block)))))
-
-  add_tests("block_pass_thingy",
-            "Ruby"         => "r.read_body(dest, &block)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :r),
-                                :read_body,
-                                s(:call, nil, :dest),
-                                s(:block_pass, s(:call, nil, :block))))
-
-  add_tests("block_stmt_after",
-            "Ruby"         => "def f\n  begin\n    b\n  rescue\n    c\n  end\n\n  d\nend",
-            "ParseTree"    => s(:defn, :f, s(:args),
-                                s(:rescue,
-                                  s(:call, nil, :b),
-                                  s(:resbody,
-                                    s(:array),
-                                    s(:call, nil, :c))),
-                                s(:call, nil, :d)),
-            "Ruby2Ruby"    => "def f\n  b rescue c\n  d\nend")
-  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",
-            "ParseTree"    => s(:defn, :f, s(:args),
-                                s(:call, nil, :a),
-                                s(:rescue, s(:call, nil, :b),
-                                  s(:resbody,
-                                    s(:array),
-                                    s(:call, nil, :c)))),
-            "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", "Ruby2Ruby"
-
-  add_tests("block_stmt_both",
-            "Ruby"         => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\n  d\nend",
-            "ParseTree"    => s(:defn, :f, s(:args),
-                                s(:call, nil, :a),
-                                s(:rescue,
-                                  s(:call, nil, :b),
-                                  s(:resbody,
-                                    s(:array),
-                                    s(:call, nil, :c))),
-                                s(:call, nil, :d)),
-            "Ruby2Ruby"    => "def f\n  a\n  b rescue c\n  d\nend")
-  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],
-            "ParseTree"    => s(:defn, :unsplatted, s(:args, :x),
-                                s(:call, s(:lvar, :x), :+, s(:lit, 1))),
-            "Ruby2Ruby"    => "def unsplatted(x)\n  (x + 1)\nend")
-
-  add_tests("bmethod_noargs",
-            "Ruby"         => [Examples, :bmethod_noargs],
-            "ParseTree"    => s(:defn, :bmethod_noargs, s(:args),
-                                s(:call,
-                                  s(:call, nil, :x),
-                                  :"+",
-                                  s(:lit, 1))),
-            "Ruby2Ruby"    => "def bmethod_noargs\n  (x + 1)\nend")
-
-  add_tests("bmethod_splat",
-            "Ruby"         => [Examples, :splatted],
-            "ParseTree"    => s(:defn, :splatted, s(:args, :"*args"),
-                                s(:lasgn, :y,
-                                  s(:call, s(:lvar, :args), :first)),
-                                s(:call, s(:lvar, :y), :+, s(:lit, 42))),
-            "Ruby2Ruby"    => "def splatted(*args)\n  y = args.first\n  (y + 42)\nend")
-
-  add_tests("break",
-            "Ruby"         => "loop { break if true }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :loop),
-                                0,
-                                s(:if, s(:true), s(:break), nil)))
-
-  add_tests("break_arg",
-            "Ruby"         => "loop { break 42 if true }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :loop),
-                                0,
-                                s(:if, s(:true), s(:break, s(:lit, 42)), nil)))
-
-  add_tests("call",
-            "Ruby"         => "self.method",
-            "ParseTree"    => s(:call, s(:self), :method))
-
-  add_tests("call_arglist",
-            "Ruby"         => "o.puts(42)",
-            "ParseTree"    => s(:call, s(:call, nil, :o), :puts, s(:lit, 42)))
-
-  add_tests("call_arglist_hash",
-            "Ruby"         => "o.m(:a => 1, :b => 2)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :o), :m,
-                                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)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :o), :m,
-                                s(:lit, 42),
-                                s(:hash,
-                                  s(:lit, :a), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2))))
-
-  add_tests("call_command",
-            "Ruby"         => "1.b(c)",
-            "ParseTree"    => s(:call,
-                                s(:lit, 1),
-                                :b,
-                                s(:call, nil, :c)))
-
-  add_tests("call_expr",
-            "Ruby"         => "(v = (1 + 1)).zero?",
-            "ParseTree"    => s(:call,
-                                s(:lasgn, :v,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                :zero?))
-
-  add_tests("call_index",
-            "Ruby"         => "a = []\na[42]\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :a, s(:array)),
-                                s(:call, s(:lvar, :a), :[], s(:lit, 42))))
-
-  add_tests("call_index_no_args",
-            "Ruby"         => "a[]",
-            "ParseTree"    => s(:call, s(:call, nil, :a),
-                                :[]))
-
-  add_tests("call_index_space",
-            "Ruby"         => "a = []\na [42]\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :a, s(:array)),
-                                s(:call, s(:lvar, :a), :[], s(:lit, 42))),
-            "Ruby2Ruby"    => "a = []\na[42]\n")
-
-  add_tests("call_no_space_symbol",
-            "Ruby"         => "foo:bar",
-            "ParseTree"    => s(:call, nil, :foo, s(:lit, :bar)),
-            "Ruby2Ruby"    => "foo(:bar)")
-
-  add_tests("call_unary_neg",
-            "Ruby"         => "-2**31",
-            "ParseTree"    => s(:call,
-                                s(:call, s(:lit, 2), :**, s(:lit, 31)),
-                                :-@),
-            "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",
-            "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(:call, nil, :puts, 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",
-            "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",
-            "ParseTree"    => s(:case, s(:call, nil, :a),
-                                s(:when,
-                                  s(:array, s(:call, nil, :b)),
-                                  s(:case, nil,
-                                    s(:when,
-                                      s(:array,
-                                        s(:and,
-                                          s(:call, nil, :d),
-                                          s(:call, nil, :e))),
-                                      s(:call, nil, :f)),
-                                    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",
-            "ParseTree"    => s(:case, nil,
-                                s(:when,
-                                  s(:array,
-                                    s(:call,
-                                      s(:call, nil, :a),
-                                      :==,
-                                      s(:lit, 1))),
-                                  s(:lit, :a)),
-                                s(:when,
-                                  s(:array,
-                                    s(:call,
-                                      s(:call, nil, :a),
-                                      :==,
-                                      s(:lit, 2))),
-                                  s(:lit, :b)),
-                                s(:lit, :c)))
-
-  add_tests("case_splat",
-            "Ruby"         => "case a\nwhen :b, *c then\n  d\nelse\n  e\nend",
-            "ParseTree"    => s(:case, s(:call, nil, :a),
-                                s(:when,
-                                  s(:array,
-                                    s(:lit, :b),
-                                    s(:splat, s(:call, nil, :c))),
-                                  s(:call, nil, :d)),
-                                s(:call, nil, :e)))
-
-  add_tests("cdecl",
-            "Ruby"         => "X = 42",
-            "ParseTree"    => s(:cdecl, :X, s(:lit, 42)))
-
-  add_tests("class_plain",
-            "Ruby"         => "class X\n  puts((1 + 1))\n  \n  def blah\n    puts(\"hello\")\n  end\nend",
-            "ParseTree"    => s(:class, :X, nil,
-                                s(:call, nil, :puts,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                s(:defn, :blah, s(:args),
-                                  s(:call, nil, :puts, s(:str, "hello")))))
-
-  add_tests("class_scoped",
-            "Ruby"         => "class X::Y\n  c\nend",
-            "ParseTree"    => s(:class, s(:colon2, s(:const, :X), :Y), nil,
-                                s(:call, nil, :c)))
-
-  add_tests("class_scoped3",
-            "Ruby"         => "class ::Y\n  c\nend",
-            "ParseTree"    => s(:class, s(:colon3, :Y), nil,
-                                s(:call, nil, :c)))
-
-  add_tests("class_super_array",
-            "Ruby"         => "class X < Array\nend",
-            "ParseTree"    => s(:class, :X, s(:const, :Array)))
-
-  add_tests("class_super_expr",
-            "Ruby"         => "class X < expr\nend",
-            "ParseTree"    => s(:class, :X, s(:call, nil, :expr)))
-
-  add_tests("class_super_object",
-            "Ruby"         => "class X < Object\nend",
-            "ParseTree"    => s(:class, :X, s(:const, :Object)))
-
-  add_tests("colon2",
-            "Ruby"         => "X::Y",
-            "ParseTree"    => s(:colon2, s(:const, :X), :Y))
-
-  add_tests("colon3",
-            "Ruby"         => "::X",
-            "ParseTree"    => s(:colon3, :X))
-
-  add_tests("const",
-            "Ruby"         => "X",
-            "ParseTree"    => s(:const, :X))
-
-  add_tests("constX",
-            "Ruby"         => "X = 1",
-            "ParseTree"    => s(:cdecl, :X, s(:lit, 1)))
-
-  add_tests("constY",
-            "Ruby"         => "::X = 1",
-            "ParseTree"    => s(:cdecl, s(:colon3, :X), s(:lit, 1)))
-
-  add_tests("constZ",
-            "Ruby"         => "X::Y = 1",
-            "ParseTree"    => s(:cdecl,
-                                s(:colon2, s(:const, :X), :Y),
-                                s(:lit, 1)))
-
-  add_tests("cvar",
-            "Ruby"         => "@@x",
-            "ParseTree"    => s(:cvar, :@@x))
-
-  add_tests("cvasgn",
-            "Ruby"         => "def x\n  @@blah = 1\nend",
-            "ParseTree"    => s(:defn, :x, s(:args),
-                                s(:cvasgn, :@@blah, s(:lit, 1))))
-
-  add_tests("cvasgn_cls_method",
-            "Ruby"         => "def self.quiet_mode=(boolean)\n  @@quiet_mode = boolean\nend",
-            "ParseTree"    => s(:defs, s(:self), :quiet_mode=,
-                                s(:args, :boolean),
-                                s(:cvasgn, :@@quiet_mode,
-                                  s(:lvar, :boolean))))
-
-  add_tests("cvdecl",
-            "Ruby"         => "class X\n  @@blah = 1\nend",
-            "ParseTree"    => s(:class, :X, nil,
-                                s(:cvdecl, :@@blah, s(:lit, 1))))
-
-  add_tests("dasgn_0",
-            "Ruby"         => "a.each { |x| b.each { |y| x = (x + 1) } if true }",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :a), :each),
-                                s(:args, :x),
-                                s(:if, s(:true),
-                                  s(:iter,
-                                    s(:call, s(:call, nil, :b), :each),
-                                    s(:args, :y),
-                                    s(:lasgn, :x,
-                                      s(:call, s(:lvar, :x), :+, s(:lit, 1)))),
-                                  nil)))
-
-  add_tests("dasgn_1",
-            "Ruby"         => "a.each { |x| b.each { |y| c = (c + 1) } if true }",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :a), :each),
-                                s(:args, :x),
-                                s(:if, s(:true),
-                                  s(:iter,
-                                    s(:call, s(:call, nil, :b), :each),
-                                    s(:args, :y),
-                                    s(:lasgn, :c,
-                                      s(:call, s(:lvar, :c), :+, s(:lit, 1)))),
-                                  nil)))
-
-  add_tests("dasgn_2",
-            "Ruby"         => "a.each do |x|\n  if true then\n    c = 0\n    b.each { |y| c = (c + 1) }\n  end\nend",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :a), :each),
-                                s(:args, :x),
-                                s(:if, s(:true),
-                                  s(:block,
-                                    s(:lasgn, :c, s(:lit, 0)),
-                                    s(:iter,
-                                      s(:call, s(:call, nil, :b), :each),
-                                      s(:args, :y),
-                                      s(:lasgn, :c,
-                                        s(:call, s(:lvar, :c), :+,
-                                          s(:lit, 1))))),
-                                  nil)))
-
-  add_tests("dasgn_curr",
-            "Ruby"         => "data.each do |x, y|\n  a = 1\n  b = a\n  b = a = x\nend",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :data), :each),
-                                s(:args, :x, :y),
-                                s(:block,
-                                  s(:lasgn, :a, s(:lit, 1)),
-                                  s(:lasgn, :b, s(:lvar, :a)),
-                                  s(:lasgn, :b, s(:lasgn, :a, s(:lvar, :x))))))
-
-  add_tests("dasgn_icky",
-            "Ruby"         => "a do\n  v = nil\n  assert_block(full_message) do\n    begin\n      yield\n    rescue Exception => v\n      break\n    end\n  end\nend",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                0,
-                                s(:block,
-                                  s(:lasgn, :v, s(:nil)),
-                                  s(:iter,
-                                    s(:call, nil, :assert_block,
-                                      s(:call, nil, :full_message)),
-                                    0,
-                                    s(:rescue,
-                                      s(:yield),
-                                      s(:resbody,
-                                        s(:array,
-                                          s(:const, :Exception),
-                                          s(:lasgn, :v, s(:gvar, :$!))),
-                                        s(:break)))))))
-
-  add_tests("dasgn_mixed",
-            "Ruby"         => "t = 0\nns.each { |n| t += n }\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :t, s(:lit, 0)),
-                                s(:iter,
-                                  s(:call, s(:call, nil, :ns), :each),
-                                  s(:args, :n),
-                                  s(:lasgn, :t,
-                                    s(:call, s(:lvar, :t), :+, s(:lvar, :n))))),
-            "Ruby2Ruby"    => "t = 0\nns.each { |n| t = (t + n) }\n")
-
-  add_tests("defined",
-            "Ruby"         => "defined? $x",
-            "ParseTree"    => s(:defined, s(:gvar, :$x)))
-
-  add_tests("defn_args_block", # TODO: make all the defn_args* p their arglist
-            "Ruby"         => "def f(&block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f, s(:args, :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand",
-            "Ruby"         => "def f(mand)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f, s(:args, :mand),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_block",
-            "Ruby"         => "def f(mand, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f, s(:args, :mand, :"&block"),
-                                 s(:nil)))
-
-  add_tests("defn_args_mand_opt",
-            "Ruby"         => "def f(mand, opt = 42)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, s(:lasgn, :opt, s(:lit, 42))),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_opt_block",
-            "Ruby"         => "def f(mand, opt = 42, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_opt_splat",
-            "Ruby"         => "def f(mand, opt = 42, *rest)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"*rest"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_opt_splat_block",
-            "Ruby"         => "def f(mand, opt = 42, *rest, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_opt_splat_no_name",
-            "Ruby"         => "def x(a, b = 42, *)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :x,
-                                s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_splat",
-            "Ruby"         => "def f(mand, *rest)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, :"*rest"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_splat_block",
-            "Ruby"         => "def f(mand, *rest, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, :mand, :"*rest", :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_mand_splat_no_name",
-            "Ruby"         => "def x(a, *args)\n  p(a, args)\nend",
-            "ParseTree"    => s(:defn, :x, s(:args, :a, :"*args"),
-                                s(:call, nil, :p,
-                                  s(:lvar, :a), s(:lvar, :args))))
-
-  add_tests("defn_args_none",
-            "Ruby"         => "def empty\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :empty, s(:args),
-                                s(:nil)))
-
-  add_tests("defn_args_opt",
-            "Ruby"         => "def f(opt = 42)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, s(:lasgn, :opt, s(:lit, 42))),
-                                s(:nil)))
-
-  add_tests("defn_args_opt_block",
-            "Ruby"         => "def f(opt = 42, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, s(:lasgn, :opt, s(:lit, 42)), :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_opt_splat",
-            "Ruby"         => "def f(opt = 42, *rest)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args, s(:lasgn, :opt, s(:lit, 42)), :"*rest"),
-                                s(:nil)))
-
-  add_tests("defn_args_opt_splat_block",
-            "Ruby"         => "def f(opt = 42, *rest, &block)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f,
-                                s(:args,
-                                  s(:lasgn, :opt, s(:lit, 42)),
-                                  :"*rest", :"&block"),
-                                s(:nil)))
-
-  add_tests("defn_args_opt_splat_no_name",
-            "Ruby"         => "def x(b = 42, *)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :x,
-                                s(:args, s(:lasgn, :b, s(:lit, 42)), :"*"),
-                                s(:nil)))
-
-  add_tests("defn_args_splat",
-            "Ruby"         => "def f(*rest)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :f, s(:args, :"*rest"),
-                                s(:nil)))
-
-  add_tests("defn_args_splat_no_name",
-            "Ruby"         => "def x(*)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :x, s(:args, :"*"),
-                                s(:nil)))
-
-  add_tests("defn_or",
-            "Ruby"         => "def |(o)\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :|, s(:args, :o),
-                                s(:nil)))
-
-  add_tests("defn_rescue",
-            "Ruby"         => "def eql?(resource)\n  (self.uuid == resource.uuid)\nrescue\n  false\nend",
-            "ParseTree"    => s(:defn, :eql?,
-                                s(:args, :resource),
-                                s(:rescue,
-                                  s(:call,
-                                    s(:call, s(:self), :uuid),
-                                    :==,
-                                    s(:call, s(:lvar, :resource), :uuid)),
-                                  s(:resbody, s(:array), s(:false)))),
-            "Ruby2Ruby"    => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend")
-
-  add_tests("defn_rescue_mri_verbose_flag",
-            "Ruby"         => "def eql?(resource)\n  (self.uuid == resource.uuid)\nrescue\n  false\nend",
-            "ParseTree"    => s(:defn, :eql?,
-                                s(:args, :resource),
-                                s(:rescue,
-                                  s(:call,
-                                    s(:call, s(:self), :uuid),
-                                    :==,
-                                    s(:call, s(:lvar, :resource), :uuid)),
-                                  s(:resbody, s(:array), s(:false)))),
-            "Ruby2Ruby"    => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend")
-
-  add_tests("defn_something_eh",
-            "Ruby"         => "def something?\n  # do nothing\nend",
-            "ParseTree"    => s(:defn, :something?,
-                                s(:args),
-                                s(:nil)))
-
-  add_tests("defn_splat_no_name",
-            "Ruby"         => "def x(a, *)\n  p(a)\nend",
-            "ParseTree"    => s(:defn, :x,
-                                s(:args, :a, :"*"),
-                                s(:call, nil, :p, s(:lvar, :a))))
-
-  add_tests("defn_zarray",
-            "Ruby"         => "def zarray\n  a = []\n  return a\nend",
-            "ParseTree"    => s(:defn, :zarray,
-                                s(:args),
-                                s(:lasgn, :a, s(:array)),
-                                s(:return, s(:lvar, :a))))
-
-  add_tests("defs",
-            "Ruby"         => "def self.x(y)\n  (y + 1)\nend",
-            "ParseTree"    => s(:defs, s(:self), :x,
-                                s(:args, :y),
-                                s(:call, s(:lvar, :y), :+, s(:lit, 1))))
-
-  add_tests("defs_empty",
-            "Ruby"         => "def self.empty\n  # do nothing\nend",
-            "ParseTree"    => s(:defs, s(:self), :empty, s(:args), s(:nil)))
-
-  add_tests("defs_empty_args",
-            "Ruby"         => "def self.empty(*)\n  # do nothing\nend",
-            "ParseTree"    => s(:defs, s(:self), :empty,
-                                s(:args, :*),
-                                s(:nil)))
-
-  add_tests("defs_expr_wtf",
-            "Ruby"         => "def (a.b).empty(*)\n  # do nothing\nend",
-            "ParseTree"    => s(:defs,
-                                s(:call, s(:call, nil, :a), :b),
-                                :empty,
-                                s(:args, :*),
-                                s(:nil)))
-
-  add_tests("dmethod",
-            "Ruby"         => [Examples, :dmethod_added],
-            "ParseTree"    => s(:defn, :dmethod_added,
-                                s(:args, :x),
-                                s(:call, s(:lvar, :x), :+, s(:lit, 1))),
-            "Ruby2Ruby"    => "def dmethod_added(x)\n  (x + 1)\nend")
-
-  add_tests("dot2",
-            "Ruby"         => "(a..b)",
-            "ParseTree"    => s(:dot2,
-                                s(:call, nil, :a),
-                                s(:call, nil, :b)))
-
-  add_tests("dot3",
-            "Ruby"         => "(a...b)",
-            "ParseTree"    => s(:dot3,
-                                s(:call, nil, :a),
-                                s(:call, nil, :b)))
-
-  add_tests("dregx",
-            "Ruby"         => "/x#\{(1 + 1)}y/",
-            "ParseTree"    => s(:dregx, "x",
-                                s(:evstr,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                s(:str, "y")))
-
-  add_tests("dregx_interp",
-            "Ruby"         => "/#\{@rakefile}/",
-            "ParseTree"    => s(:dregx, "", s(:evstr, s(:ivar, :@rakefile))))
-
-  add_tests("dregx_interp_empty",
-            "Ruby"         => "/a#\{}b/",
-            "ParseTree"    => s(:dregx, "a", s(:evstr), s(:str, "b")))
-
-  add_tests("dregx_n",
-            "Ruby"         => '/#{1}/n',
-            "ParseTree"    => s(:dregx, "",
-                                s(:evstr, s(:lit, 1)), /x/n.options))
-
-  add_tests("dregx_once",
-            "Ruby"         => "/x#\{(1 + 1)}y/o",
-            "ParseTree"    => s(:dregx_once, "x",
-                                s(:evstr,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                s(:str, "y")))
-
-  add_tests("dregx_once_n_interp",
-            "Ruby"         => "/#\{IAC}#\{SB}/no",
-            "ParseTree"    => s(:dregx_once, "",
-                                s(:evstr, s(:const, :IAC)),
-                                s(:evstr, s(:const, :SB)), /x/n.options))
-
-  add_tests("dstr",
-            "Ruby"         => "argl = 1\n\"x#\{argl}y\"\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :argl, s(:lit, 1)),
-                                s(:dstr, "x", s(:evstr, s(:lvar, :argl)),
-                                  s(:str, "y"))))
-
-  add_tests("dstr_2",
-            "Ruby"         => "argl = 1\n\"x#\{(\"%.2f\" % 3.14159)}y\"\n",
-            "ParseTree"    =>   s(:block,
-                                  s(:lasgn, :argl, s(:lit, 1)),
-                                  s(:dstr,
-                                    "x",
-                                    s(:evstr,
-                                      s(:call, s(:str, "%.2f"), :%,
-                                        s(:lit, 3.14159))),
-                                    s(:str, "y"))))
-
-  add_tests("dstr_3",
-            "Ruby"         => "max = 2\nargl = 1\n\"x#\{(\"%.#\{max}f\" % 3.14159)}y\"\n",
-            "ParseTree"    =>   s(:block,
-                                  s(:lasgn, :max, s(:lit, 2)),
-                                  s(:lasgn, :argl, s(:lit, 1)),
-                                  s(:dstr, "x",
-                                    s(:evstr,
-                                      s(:call,
-                                        s(:dstr, "%.",
-                                          s(:evstr, s(:lvar, :max)),
-                                          s(:str, "f")),
-                                        :%,
-                                        s(:lit, 3.14159))),
-                                    s(:str, "y"))))
-
-  add_tests("dstr_concat",
-            "Ruby"         => '"#{22}aa" "cd#{44}" "55" "#{66}"',
-            "ParseTree"    => s(:dstr,
-                                "",
-                                s(:evstr, s(:lit, 22)),
-                                s(:str, "aa"),
-                                s(:str, "cd"),
-                                s(:evstr, s(:lit, 44)),
-                                s(:str, "55"),
-                                s(:evstr, s(:lit, 66))),
-            "Ruby2Ruby"    => '"#{22}aacd#{44}55#{66}"')
-
-  add_tests("dstr_gross",
-            "Ruby"         => '"a #$global b #@ivar c #@@cvar d"',
-            "ParseTree"    => s(:dstr, "a ",
-                                s(:evstr, s(:gvar, :$global)),
-                                s(:str, " b "),
-                                s(:evstr, s(:ivar, :@ivar)),
-                                s(:str, " c "),
-                                s(:evstr, s(:cvar, :@@cvar)),
-                                s(:str, " d")),
-            "Ruby2Ruby" => '"a #{$global} b #{@ivar} c #{@@cvar} d"')
-
-  add_tests("dstr_heredoc_expand",
-            "Ruby"         => "<<EOM\n  blah\n#\{1 + 1}blah\nEOM\n",
-            "ParseTree"    => s(:dstr, "  blah\n",
-                                s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                s(:str, "blah\n")),
-            "Ruby2Ruby"    => "\"  blah\\n#\{(1 + 1)}blah\\n\"")
-
-  add_tests("dstr_heredoc_windoze_sucks",
-            "Ruby"         => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n  EOF\r\n",
-            "ParseTree"    => s(:dstr,
-                                "def test_",
-                                s(:evstr, s(:call, nil, :action)),
-                                s(:str, "_valid_feed\n")),
-            "Ruby2Ruby"    => "\"def test_#\{action}_valid_feed\\n\"")
-
-  add_tests("dstr_heredoc_yet_again",
-            "Ruby"         => "<<-EOF\ns1 '#\{RUBY_PLATFORM}' s2\n#\{__FILE__}\n        EOF\n",
-            "ParseTree"    => s(:dstr, "s1 '",
-                                s(:evstr, s(:const, :RUBY_PLATFORM)),
-                                s(:str, "' s2\n"),
-                                s(:str, "(string)"),
-                                s(:str, "\n")),
-            "Ruby2Ruby"    => "\"s1 '#\{RUBY_PLATFORM}' s2\\n(string)\\n\"")
-
-  add_tests("dstr_nest",
-            "Ruby"         => "%Q[before [#\{nest}] after]",
-            "ParseTree"    => s(:dstr, "before [",
-                                s(:evstr, s(:call, nil, :nest)),
-                                s(:str, "] after")),
-            "Ruby2Ruby"    => "\"before [#\{nest}] after\"")
-
-  add_tests("dstr_str_lit_start",
-            "Ruby"         => '"#{"blah"}#{__FILE__}:#{__LINE__}: warning: #{$!.message} (#{$!.class})"',
-            "ParseTree"    => s(:dstr,
-                                "blah(string):",
-                                s(:evstr, s(:lit, 1)),
-                                s(:str, ": warning: "),
-                                s(:evstr, s(:call, s(:gvar, :$!), :message)),
-                                s(:str, " ("),
-                                s(:evstr, s(:call, s(:gvar, :$!), :class)),
-                                s(:str, ")")),
-            "Ruby2Ruby"    => '"blah(string):#{1}: warning: #{$!.message} (#{$!.class})"')
-
-  add_tests("dstr_the_revenge",
-            "Ruby"         => '"before #{from} middle #{to} (#{__FILE__}:#{__LINE__})"',
-            "ParseTree"    => s(:dstr,
-                                "before ",
-                                s(:evstr, s(:call, nil, :from)),
-                                s(:str, " middle "),
-                                s(:evstr, s(:call, nil, :to)),
-                                s(:str, " ("),
-                                s(:str, "(string)"),
-                                s(:str, ":"),
-                                s(:evstr, s(:lit, 1)),
-                                s(:str, ")")),
-            "Ruby2Ruby"    => '"before #{from} middle #{to} ((string):#{1})"')
-
-  add_tests("dsym",
-            "Ruby"         => ":\"x#\{(1 + 1)}y\"",
-            "ParseTree"    => s(:dsym, "x",
-                                s(:evstr, s(:call, s(:lit, 1), :+, s(:lit, 1))),
-                                s(:str, "y")))
-
-  add_tests("dxstr",
-            "Ruby"         => "t = 5\n`touch #\{t}`\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :t, s(:lit, 5)),
-                                s(:dxstr, "touch ", s(:evstr, s(:lvar, :t)))))
-
-  add_tests("ensure",
-            "Ruby"         => "begin\n  (1 + 1)\nrescue SyntaxError => e1\n  2\nrescue Exception => e2\n  3\nelse\n  4\nensure\n  5\nend",
-            "ParseTree"    => s(:ensure,
-                                s(:rescue,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 1)),
-                                  s(:resbody,
-                                    s(:array,
-                                      s(:const, :SyntaxError),
-                                      s(:lasgn, :e1, s(:gvar, :$!))),
-                                    s(:lit, 2)),
-                                  s(:resbody,
-                                    s(:array,
-                                      s(:const, :Exception),
-                                      s(:lasgn, :e2, s(:gvar, :$!))),
-                                    s(:lit, 3)),
-                                  s(:lit, 4)),
-                                s(:lit, 5)))
-
-  add_tests("false",
-            "Ruby"         => "false",
-            "ParseTree"    => s(:false))
-
-  add_tests("fbody",
-            "Ruby"         => [Examples, :an_alias],
-            "ParseTree"    => s(:defn, :an_alias, s(:args, :x),
-                                s(:call, s(:lvar, :x), :+, s(:lit, 1))),
-            "Ruby2Ruby"    => "def an_alias(x)\n  (x + 1)\nend")
-
-  add_tests("fcall_arglist",
-            "Ruby"         => "m(42)",
-            "ParseTree"    => s(:call, nil, :m, s(:lit, 42)))
-
-  add_tests("fcall_arglist_hash",
-            "Ruby"         => "m(:a => 1, :b => 2)",
-            "ParseTree"    => s(:call, nil, :m,
-                                s(:hash,
-                                  s(:lit, :a), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2))))
-
-  add_tests("fcall_arglist_norm_hash",
-            "Ruby"         => "m(42, :a => 1, :b => 2)",
-            "ParseTree"    => s(:call, nil, :m,
-                                s(:lit, 42),
-                                s(:hash,
-                                  s(:lit, :a), s(:lit, 1),
-                                  s(:lit, :b), s(:lit, 2))))
-
-  add_tests("fcall_block",
-            "Ruby"         => "a(:b) { :c }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a, s(:lit, :b)),
-                                0,
-                                s(:lit, :c)))
-
-  add_tests("fcall_index_space",
-            "Ruby"         => "a [42]",
-            "ParseTree"    => s(:call, nil, :a, s(:array, s(:lit, 42))),
-            "Ruby2Ruby"    => "a([42])")
-
-  add_tests("fcall_inside_parens",
-            "Ruby"         => "( a (b), c)",
-            "ParseTree"    => s(:call, nil, :a,
-                                s(:call, nil, :b), s(:call, nil, :c)),
-            "Ruby2Ruby"    => "a(b, c)")
-
-  add_tests("fcall_keyword",
-            "Ruby"         => "42 if block_given?",
-            "ParseTree"    => s(:if,
-                                s(:call, nil, :block_given?),
-                                s(:lit, 42), nil))
-
-  add_tests("flip2",
-            "Ruby"         => "x = if ((i % 4) == 0)..((i % 3) == 0) then\n  i\nelse\n  nil\nend",
-            "ParseTree"    => s(:lasgn,
-                                :x,
-                                s(:if,
-                                  s(:flip2,
-                                    s(:call,
-                                      s(:call, s(:call, nil, :i),
-                                        :%,
-                                        s(:lit, 4)),
-                                      :==,
-                                      s(:lit, 0)),
-                                    s(:call,
-                                      s(:call, s(:call, nil, :i),
-                                        :%,
-                                        s(:lit, 3)),
-                                      :==,
-                                      s(:lit, 0))),
-                                  s(:call, nil, :i),
-                                  s(:nil))))
-
-  add_tests("flip2_method",
-            "Ruby"         => "if 1..2.a?(b) then\n  nil\nend",
-            "ParseTree"    => s(:if,
-                                s(:flip2,
-                                  s(:lit, 1),
-                                  s(:call, s(:lit, 2), :a?, s(:call, nil, :b))),
-                                s(:nil),
-                                nil))
-
-  add_tests("flip3",
-            "Ruby"         => "x = if ((i % 4) == 0)...((i % 3) == 0) then\n  i\nelse\n  nil\nend",
-            "ParseTree"    => s(:lasgn,
-                                :x,
-                                s(:if,
-                                  s(:flip3,
-                                    s(:call,
-                                      s(:call, s(:call, nil, :i),
-                                        :%,
-                                        s(:lit, 4)),
-                                      :==,
-                                      s(:lit, 0)),
-                                    s(:call,
-                                      s(:call, s(:call, nil, :i),
-                                        :%,
-                                        s(:lit, 3)),
-                                      :==,
-                                      s(:lit, 0))),
-                                  s(:call, nil, :i),
-                                  s(:nil))))
-
-  add_tests("for",
-            "Ruby"         => "for o in ary do\n  puts(o)\nend",
-            "ParseTree"    => s(:for,
-                                s(:call, nil, :ary),
-                                s(:lasgn, :o),
-                                s(:call, nil, :puts, s(:lvar, :o))))
-
-  add_tests("for_no_body",
-            "Ruby"         => "for i in (0..max) do\n  # do nothing\nend",
-            "ParseTree"    => s(:for,
-                                s(:dot2,
-                                  s(:lit, 0),
-                                  s(:call, nil, :max)),
-                                s(:lasgn, :i)))
-
-  add_tests("gasgn",
-            "Ruby"         => "$x = 42",
-            "ParseTree"    => s(:gasgn, :$x, s(:lit, 42)))
-
-  add_tests("global",
-            "Ruby"         => "$stderr",
-            "ParseTree"    =>  s(:gvar, :$stderr))
-
-  add_tests("gvar",
-            "Ruby"         => "$x",
-            "ParseTree"    => s(:gvar, :$x))
-
-  add_tests("gvar_underscore",
-            "Ruby"         => "$_",
-            "ParseTree"    => s(:gvar, :$_))
-
-  add_tests("gvar_underscore_blah",
-            "Ruby"         => "$__blah",
-            "ParseTree"    => s(:gvar, :$__blah))
-
-  add_tests("hash",
-            "Ruby"         => "{ 1 => 2, 3 => 4 }",
-            "ParseTree"    => s(:hash,
-                                s(:lit, 1), s(:lit, 2),
-                                s(:lit, 3), s(:lit, 4)))
-
-  add_tests("hash_rescue",
-            "Ruby"         => "{ 1 => (2 rescue 3) }",
-            "ParseTree"    => s(:hash,
-                                s(:lit, 1),
-                                s(:rescue,
-                                  s(:lit, 2),
-                                  s(:resbody, s(:array), s(:lit, 3)))))
-
-  add_tests("iasgn",
-            "Ruby"         => "@a = 4",
-            "ParseTree"    => s(:iasgn, :@a, s(:lit, 4)))
-
-  add_tests("if_block_condition",
-            "Ruby"         => "if (x = 5\n(x + 1)) then\n  nil\nend",
-            "ParseTree"    => s(:if,
-                                s(:block,
-                                  s(:lasgn, :x, s(:lit, 5)),
-                                  s(:call, s(:lvar, :x), :+, s(:lit, 1))),
-                                s(:nil),
-                                nil))
-
-  add_tests("if_lasgn_short",
-            "Ruby"         => "if x = obj.x then\n  x.do_it\nend",
-            "ParseTree"    => s(:if,
-                                s(:lasgn, :x,
-                                  s(:call,
-                                    s(:call, nil, :obj),
-                                    :x)),
-                                s(:call, s(:lvar, :x), :do_it),
-                                nil))
-
-  add_tests("if_nested",
-            "Ruby"         => "return if false unless true",
-            "ParseTree"    => s(:if, s(:true), nil,
-                                s(:if, s(:false), s(:return), nil)))
-
-  add_tests("if_post",
-            "Ruby"         => "a if b",
-            "ParseTree"    => s(:if, s(:call, nil, :b),
-                                s(:call, nil, :a), nil))
-
-  add_tests("if_pre",
-            "Ruby"         => "if b then a end",
-            "ParseTree"    => s(:if, s(:call, nil, :b),
-                                s(:call, nil, :a), nil),
-            "Ruby2Ruby"    => "a if b")
-
-  add_tests("iter_call_arglist_space",
-            "Ruby" => "a (1) {|c|d}",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a, s(:lit, 1)),
-                                s(:args, :c),
-                                s(:call, nil, :d)),
-            "Ruby2Ruby"    => "a(1) { |c| d }")
-
-  add_tests("iter_dasgn_curr_dasgn_madness",
-            "Ruby"         => "as.each { |a|\n  b += a.b(false) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :as), :each),
-                                s(:args, :a),
-                                s(:lasgn, :b,
-                                  s(:call,
-                                    s(:lvar, :b),
-                                    :+,
-                                    s(:call, s(:lvar, :a), :b, s(:false))))),
-            "Ruby2Ruby"    => "as.each { |a| b = (b + a.b(false)) }")
-
-  add_tests("iter_downto",
-            "Ruby"         => "3.downto(1) { |n| puts(n.to_s) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:lit, 3), :downto, s(:lit, 1)),
-                                s(:args, :n),
-                                s(:call, nil, :puts,
-                                  s(:call, s(:lvar, :n), :to_s))))
-
-  add_tests("iter_each_lvar",
-            "Ruby"         => "array = [1, 2, 3]\narray.each { |x| puts(x.to_s) }\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :array,
-                                  s(:array,
-                                    s(:lit, 1), s(:lit, 2), s(:lit, 3))),
-                                s(:iter,
-                                  s(:call, s(:lvar, :array), :each),
-                                  s(:args, :x),
-                                  s(:call, nil, :puts,
-                                    s(:call, s(:lvar, :x), :to_s)))))
-
-  add_tests("iter_each_nested",
-            "Ruby"         => "array1 = [1, 2, 3]\narray2 = [4, 5, 6, 7]\narray1.each do |x|\n  array2.each do |y|\n    puts(x.to_s)\n    puts(y.to_s)\n  end\nend\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :array1,
-                                  s(:array,
-                                    s(:lit, 1), s(:lit, 2), s(:lit, 3))),
-                                s(:lasgn, :array2,
-                                  s(:array,
-                                    s(:lit, 4), s(:lit, 5),
-                                    s(:lit, 6), s(:lit, 7))),
-                                s(:iter,
-                                  s(:call, s(:lvar, :array1), :each),
-                                  s(:args, :x),
-                                  s(:iter,
-                                    s(:call, s(:lvar, :array2), :each),
-                                    s(:args, :y),
-                                    s(:block,
-                                      s(:call, nil, :puts,
-                                        s(:call, s(:lvar, :x), :to_s)),
-                                      s(:call, nil, :puts,
-                                        s(:call, s(:lvar, :y), :to_s)))))))
-
-  add_tests("iter_loop_empty",
-            "Ruby"         => "loop { }",
-            "ParseTree"    => s(:iter, s(:call, nil, :loop), 0))
-
-  add_tests("iter_masgn_2",
-            "Ruby"         => "a { |b, c| p(c) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :b, :c),
-                                s(:call, nil, :p, s(:lvar, :c))))
-
-  add_tests("iter_masgn_args_splat",
-            "Ruby"         => "a { |b, c, *d| p(c) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :b, :c, :"*d"),
-                                s(:call, nil, :p, s(:lvar, :c))))
-
-  add_tests("iter_masgn_args_splat_no_name",
-            "Ruby"         => "a { |b, c, *| p(c) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :b, :c, :*),
-                                s(:call, nil, :p, s(:lvar, :c))))
-
-  add_tests("iter_masgn_splat",
-            "Ruby"         => "a { |*c| p(c) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :"*c"),
-                                s(:call, nil, :p, s(:lvar, :c))))
-
-  add_tests("iter_masgn_splat_no_name",
-            "Ruby"         => "a { |*| p(c) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :*),
-                                s(:call, nil, :p, s(:call, nil, :c))))
-
-  add_tests("iter_shadowed_var",
-            "Ruby"         => "a do |x|\n  b do |x|\n    puts x\n  end\nend",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :a),
-                                s(:args, :x),
-                                s(:iter,
-                                  s(:call, nil, :b),
-                                  s(:args, :x),
-                                  s(:call, nil, :puts, s(:lvar, :x)))),
-            "Ruby2Ruby"    => "a { |x| b { |x| puts(x) } }")
-
-  add_tests("iter_upto",
-            "Ruby"         => "1.upto(3) { |n| puts(n.to_s) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:lit, 1), :upto, s(:lit, 3)),
-                                s(:args, :n),
-                                s(:call, nil, :puts,
-                                  s(:call, s(:lvar, :n), :to_s))))
-
-  add_tests("iter_while",
-            "Ruby"         => "argl = 10\nwhile (argl >= 1) do\n  puts(\"hello\")\n  argl = (argl - 1)\nend\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :argl, s(:lit, 10)),
-                                s(:while,
-                                  s(:call, s(:lvar, :argl), :">=", s(:lit, 1)),
-                                  s(:block,
-                                    s(:call, nil, :puts, s(:str, "hello")),
-                                    s(:lasgn,
-                                      :argl,
-                                      s(:call, s(:lvar, :argl), :"-",
-                                        s(:lit, 1)))),
-                                  true)))
-
-  add_tests("ivar",
-            "Ruby"         => [Examples, :reader],
-            "ParseTree"    => s(:defn, :reader, s(:args),
-                                s(:ivar, :@reader)),
-            "Ruby2Ruby"    => "attr_reader :reader")
-
-  add_tests("lambda_args_anon_star",
-            "Ruby"         => "lambda { |*| nil }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :*),
-                                s(:nil)))
-
-  add_tests("lambda_args_anon_star_block",
-            "Ruby"         => "lambda { |*, &block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :*, :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lambda_args_block",
-            "Ruby"         => "lambda { |&block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lambda_args_norm_anon_star",
-            "Ruby"         => "lambda { |a, *| a }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :*),
-                                s(:lvar, :a)))
-
-  add_tests("lambda_args_norm_anon_star_block",
-            "Ruby"         => "lambda { |a, *, &block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :*, :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lambda_args_norm_block",
-            "Ruby"         => "lambda { |a, &block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lambda_args_norm_comma",
-            "Ruby"         => "lambda { |a,| a }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a),
-                                s(:lvar, :a)),
-            "Ruby2Ruby"    => "lambda { |a| a }")
-
-  add_tests("lambda_args_norm_comma2",
-            "Ruby"         => "lambda { |a,b,| a }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :b),
-                                s(:lvar, :a)),
-            "Ruby2Ruby"    => "lambda { |a, b| a }")
-
-  add_tests("lambda_args_norm_star",
-            "Ruby"         => "lambda { |a, *star| star }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :"*star"),
-                                s(:lvar, :star)))
-
-  add_tests("lambda_args_norm_star_block",
-            "Ruby"         => "lambda { |a, *star, &block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :a, :"*star", :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lambda_args_star",
-            "Ruby"         => "lambda { |*star| star }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :"*star"),
-                                s(:lvar, :star)))
-
-  add_tests("lambda_args_star_block",
-            "Ruby"         => "lambda { |*star, &block| block }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :lambda),
-                                s(:args, :"*star", :"&block"),
-                                s(:lvar, :block)))
-
-  add_tests("lasgn_array",
-            "Ruby"         => "var = [\"foo\", \"bar\"]",
-            "ParseTree"    => s(:lasgn, :var,
-                                s(:array,
-                                  s(:str, "foo"),
-                                  s(:str, "bar"))))
-
-  add_tests("lasgn_call",
-            "Ruby"         => "c = (2 + 3)",
-            "ParseTree"    => s(:lasgn, :c,
-                                s(:call, s(:lit, 2), :+, s(:lit, 3))))
-
-  add_tests("lit_bool_false",
-            "Ruby"         => "false",
-            "ParseTree"    => s(:false))
-
-  add_tests("lit_bool_true",
-            "Ruby"         => "true",
-            "ParseTree"    => s(:true))
-
-  add_tests("lit_float",
-            "Ruby"         => "1.1",
-            "ParseTree"    => s(:lit, 1.1))
-
-  add_tests("lit_long",
-            "Ruby"         => "1",
-            "ParseTree"    => s(:lit, 1))
-
-  add_tests("lit_long_negative",
-            "Ruby"         => "-1",
-            "ParseTree"    => s(:lit, -1))
-
-  add_tests("lit_range2",
-            "Ruby"         => "(1..10)",
-            "ParseTree"    => s(:lit, 1..10))
-
-  add_tests("lit_range3",
-            "Ruby"         => "(1...10)",
-            "ParseTree"    => s(:lit, 1...10))
-
-  add_tests("lit_regexp",
-            "Ruby"         => "/x/",
-            "ParseTree"    => s(:lit, /x/))
-
-  add_tests("lit_regexp_i_wwtt",
-            "Ruby"         => "str.split(//i)",
-            "ParseTree"    => s(:call,
-                                s(:call, nil, :str),
-                                :split,
-                                s(:lit, //i)))
-
-  add_tests("lit_regexp_n",
-            "Ruby"         => "/x/n", # HACK differs on 1.9 - this is easiest
-            "ParseTree"    => s(:lit, /x/n),
-            "Ruby2Ruby"    => /x/n.inspect)
-
-  add_tests("lit_regexp_once",
-            "Ruby"         => "/x/o",
-            "ParseTree"    => s(:lit, /x/),
-            "Ruby2Ruby"    => "/x/")
-
-  add_tests("lit_sym",
-            "Ruby"         => ":x",
-            "ParseTree"    => s(:lit, :x))
-
-  add_tests("lit_sym_splat",
-            "Ruby"         => ":\"*args\"",
-            "ParseTree"    => s(:lit, :"*args"))
-
-  add_tests("lvar_def_boundary",
-            "Ruby"         => "b = 42\ndef a\n  c do\n    begin\n      do_stuff\n    rescue RuntimeError => b\n      puts(b)\n    end\n  end\nend\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :b, s(:lit, 42)),
-                                s(:defn, :a, s(:args),
-                                  s(:iter,
-                                    s(:call, nil, :c),
-                                    0,
-                                    s(:rescue,
-                                      s(:call, nil, :do_stuff),
-                                      s(:resbody,
-                                        s(:array,
-                                          s(:const, :RuntimeError),
-                                          s(:lasgn, :b, s(:gvar, :$!))),
-                                        s(:call, nil, :puts,
-                                          s(:lvar, :b))))))))
-
-  add_tests("masgn",
-            "Ruby"         => "a, b = c, d",
-            "ParseTree"    => s(:masgn,
-                                s(:array, s(:lasgn, :a), s(:lasgn, :b)),
-                                s(:array, s(:call, nil, :c),
-                                  s(:call, nil, :d))))
-
-  add_tests("masgn_argscat",
-            "Ruby"         => "a, b, *c = 1, 2, *[3, 4]",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b),
-                                  s(:splat, s(:lasgn, :c))),
-                                s(:array,
-                                  s(:lit, 1), s(:lit, 2),
-                                  s(:splat,
-                                    s(:array, s(:lit, 3), s(:lit, 4))))))
-
-  add_tests("masgn_attrasgn",
-            "Ruby"         => "a, b.c = d, e",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:attrasgn,
-                                    s(:call, nil, :b),
-                                    :c=)),
-                                s(:array,
-                                  s(:call, nil, :d),
-                                  s(:call, nil, :e))))
-
-  add_tests("masgn_attrasgn_array_rhs",
-            "Ruby"         => "a.b, a.c, _ = q",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:attrasgn,
-                                    s(:call, nil, :a),
-                                    :b=),
-                                  s(:attrasgn,
-                                    s(:call, nil, :a),
-                                    :c=),
-                                  s(:lasgn, :_)),
-                                s(:to_ary,
-                                  s(:call, nil, :q))))
-
-  add_tests("masgn_attrasgn_idx",
-            "Ruby"         => "a, i, j = [], 1, 2\na[i], a[j] = a[j], a[i]\n",
-            "ParseTree"    => s(:block,
-                                s(:masgn,
-                                  s(:array,
-                                    s(:lasgn, :a),
-                                    s(:lasgn, :i), s(:lasgn, :j)),
-                                  s(:array, s(:array), s(:lit, 1), s(:lit, 2))),
-                                s(:masgn,
-                                  s(:array,
-                                    s(:attrasgn,
-                                      s(:lvar, :a), :[]=, s(:lvar, :i)),
-                                    s(:attrasgn,
-                                      s(:lvar, :a), :[]=, s(:lvar, :j))),
-                                  s(:array,
-                                    s(:call,
-                                      s(:lvar, :a), :[], s(:lvar, :j)),
-                                    s(:call,
-                                      s(:lvar, :a), :[], s(:lvar, :i))))))
-
-  add_tests("masgn_cdecl",
-            "Ruby"         => "A, B, C = 1, 2, 3",
-            "ParseTree"    => s(:masgn,
-                               s(:array, s(:cdecl, :A), s(:cdecl, :B),
-                                s(:cdecl, :C)),
-                               s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3))))
-
-  add_tests("masgn_iasgn",
-            "Ruby"         => "a, @b = c, d",
-            "ParseTree"    => s(:masgn,
-                                s(:array, s(:lasgn, :a), s(:iasgn, :"@b")),
-                                s(:array,
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d))))
-
-  add_tests("masgn_masgn",
-            "Ruby"         => "a, (b, c) = [1, [2, 3]]",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:masgn,
-                                    s(:array,
-                                      s(:lasgn, :b),
-                                      s(:lasgn, :c)))),
-                                s(:to_ary,
-                                  s(:array,
-                                    s(:lit, 1),
-                                    s(:array,
-                                      s(:lit, 2),
-                                      s(:lit, 3))))))
-
-  add_tests("masgn_splat_lhs",
-            "Ruby"         => "a, b, *c = d, e, f, g",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b),
-                                  s(:splat, s(:lasgn, :c))),
-                                s(:array,
-                                  s(:call, nil, :d),
-                                  s(:call, nil, :e),
-                                  s(:call, nil, :f),
-                                  s(:call, nil, :g))))
-
-  add_tests("masgn_splat_no_name_to_ary",
-            "Ruby"         => "a, b, * = c",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b),
-                                  s(:splat)),
-                                s(:to_ary, s(:call, nil, :c))))
-
-  add_tests("masgn_splat_no_name_trailing",
-            "Ruby"         => "a, b, = c",
-            "ParseTree"    => s(:masgn,
-                                s(:array, s(:lasgn, :a), s(:lasgn, :b)),
-                                s(:to_ary, s(:call, nil, :c))),
-            "Ruby2Ruby"    => "a, b = c") # TODO: check this is right
-
-  add_tests("masgn_splat_rhs_1",
-            "Ruby"         => "a, b = *c",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b)),
-                                s(:splat, s(:call, nil, :c))))
-
-  add_tests("masgn_splat_rhs_n",
-            "Ruby"         => "a, b = c, d, *e",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b)),
-                                s(:array,
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d),
-                                  s(:splat, s(:call, nil, :e)))))
-
-  add_tests("masgn_splat_to_ary",
-            "Ruby"         => "a, b, *c = d",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b),
-                                  s(:splat, s(:lasgn, :c))),
-                                s(:to_ary, s(:call, nil, :d))))
-
-  add_tests("masgn_splat_to_ary2",
-            "Ruby"         => "a, b, *c = d.e(\"f\")",
-            "ParseTree"    => s(:masgn,
-                                s(:array,
-                                  s(:lasgn, :a),
-                                  s(:lasgn, :b),
-                                  s(:splat, s(:lasgn, :c))),
-                                s(:to_ary,
-                                  s(:call,
-                                    s(:call, nil, :d),
-                                    :e,
-                                    s(:str, "f")))))
-
-  add_tests("match",
-            "Ruby"         => "1 if /x/",
-            "ParseTree"    => s(:if, s(:match, s(:lit, /x/)), s(:lit, 1), nil))
-
-  add_tests("match2",
-            "Ruby"         => "/x/ =~ \"blah\"",
-            "ParseTree"    => s(:match2, s(:lit, /x/), s(:str, "blah")))
-
-  add_tests("match3",
-            "Ruby"         => "\"blah\" =~ /x/",
-            "ParseTree"    => s(:match3, s(:lit, /x/), s(:str, "blah")))
-
-  add_tests("module",
-            "Ruby"         => "module X\n  def y\n    # do nothing\n  end\nend",
-            "ParseTree"    => s(:module, :X,
-                                s(:defn, :y, s(:args), s(:nil))))
-
-  add_tests("module2",
-            "Ruby"         => "module X\n  def y\n    # do nothing\n  end\n  \n  def z\n    # do nothing\n  end\nend",
-            "ParseTree"    => s(:module, :X,
-                                s(:defn, :y, s(:args), s(:nil)),
-                                s(:defn, :z, s(:args), s(:nil))))
-
-  add_tests("module_scoped",
-            "Ruby"         => "module X::Y\n  c\nend",
-            "ParseTree"    => s(:module, s(:colon2, s(:const, :X), :Y),
-                                s(:call, nil, :c)))
-
-  add_tests("module_scoped3",
-            "Ruby"         => "module ::Y\n  c\nend",
-            "ParseTree"    => s(:module, s(:colon3, :Y),
-                                s(:call, nil, :c)))
-
-  add_tests("next",
-            "Ruby"         => "loop { next if false }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :loop),
-                                0,
-                                s(:if, s(:false), s(:next), nil)))
-
-  add_tests("next_arg",
-            "Ruby"         => "loop { next 42 if false }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :loop),
-                                0,
-                                s(:if, s(:false), s(:next, s(:lit, 42)), nil)))
-
-  add_tests("nth_ref",
-            "Ruby"         => "$1",
-            "ParseTree"    => s(:nth_ref, 1))
-
-  add_tests("op_asgn1",
-            "Ruby"         => "b = []\nb[1] ||= 10\nb[2] &&= 11\nb[3] += 12\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :b, s(:array)),
-                                s(:op_asgn1, s(:lvar, :b),
-                                  s(:arglist, s(:lit, 1)), :"||", s(:lit, 10)),
-                                s(:op_asgn1, s(:lvar, :b),
-                                  s(:arglist, s(:lit, 2)), :"&&", s(:lit, 11)),
-                                s(:op_asgn1, s(:lvar, :b),
-                                  s(:arglist, s(:lit, 3)), :+, s(:lit, 12))))
-
-  add_tests("op_asgn1_ivar",
-            "Ruby"         => "@b = []\n@b[1] ||= 10\n@b[2] &&= 11\n@b[3] += 12\n",
-            "ParseTree"    => s(:block,
-                                s(:iasgn, :@b, s(:array)),
-                                s(:op_asgn1, s(:ivar, :@b),
-                                  s(:arglist, s(:lit, 1)), :"||", s(:lit, 10)),
-                                s(:op_asgn1, s(:ivar, :@b),
-                                  s(:arglist, s(:lit, 2)), :"&&", s(:lit, 11)),
-                                s(:op_asgn1, s(:ivar, :@b),
-                                  s(:arglist, s(:lit, 3)), :+, s(:lit, 12))))
-
-  add_tests("op_asgn2",
-            "Ruby"         => "s = Struct.new(:var)\nc = s.new(nil)\nc.var ||= 20\nc.var &&= 21\nc.var += 22\nc.d.e.f ||= 42\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :s,
-                                  s(:call,
-                                    s(:const, :Struct),
-                                    :new,
-                                    s(:lit, :var))),
-                                s(:lasgn, :c,
-                                  s(:call, s(:lvar, :s), :new, s(:nil))),
-                                s(:op_asgn2, s(:lvar, :c),
-                                  :var=, :"||", s(:lit, 20)),
-                                s(:op_asgn2, s(:lvar, :c),
-                                  :var=, :"&&", s(:lit, 21)),
-                                s(:op_asgn2, s(:lvar, :c),
-                                  :var=, :+, s(:lit, 22)),
-                                s(:op_asgn2,
-                                  s(:call,
-                                    s(:call, s(:lvar, :c), :d),
-                                    :e),
-                                  :f=, :"||", s(:lit, 42))))
-
-  add_tests("op_asgn2_self",
-            "Ruby"         => "self.Bag ||= Bag.new",
-            "ParseTree"    => s(:op_asgn2, s(:self), :"Bag=", :"||",
-                                s(:call, s(:const, :Bag), :new)))
-
-  add_tests("op_asgn_and",
-            "Ruby"         => "a = 0\na &&= 2\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :a, s(:lit, 0)),
-                                s(:op_asgn_and,
-                                  s(:lvar, :a), s(:lasgn, :a, s(:lit, 2)))))
-
-  add_tests("op_asgn_and_ivar2",
-            "Ruby"         => "@fetcher &&= new(Gem.configuration[:http_proxy])",
-            "ParseTree"    => s(:op_asgn_and,
-                                s(:ivar, :@fetcher),
-                                s(:iasgn,
-                                  :@fetcher,
-                                  s(:call, nil,
-                                    :new,
-                                    s(:call,
-                                      s(:call, s(:const, :Gem), :configuration),
-                                      :[],
-                                      s(:lit, :http_proxy))))))
-
-  add_tests("op_asgn_or",
-            "Ruby"         => "a = 0\na ||= 1\n",
-            "ParseTree"    => s(:block,
-                                s(:lasgn, :a, s(:lit, 0)),
-                                s(:op_asgn_or,
-                                  s(:lvar, :a), s(:lasgn, :a, s(:lit, 1)))))
-
-  add_tests("op_asgn_or_block",
-            "Ruby"         => "a ||= begin\n        b\n      rescue\n        c\n      end",
-            "ParseTree"    => s(:op_asgn_or,
-                                s(:lvar, :a),
-                                s(:lasgn, :a,
-                                  s(:rescue,
-                                    s(:call, nil, :b),
-                                    s(:resbody, s(:array),
-                                      s(:call, nil, :c))))),
-            "Ruby2Ruby"    => "a ||= b rescue c")
-
-  add_tests("op_asgn_or_ivar",
-            "Ruby"         => "@v ||= {}",
-            "ParseTree"    => s(:op_asgn_or,
-                                s(:ivar, :@v),
-                                s(:iasgn, :@v, s(:hash))))
-
-  add_tests("op_asgn_or_ivar2",
-            "Ruby"         => "@fetcher ||= new(Gem.configuration[:http_proxy])",
-            "ParseTree"    => s(:op_asgn_or,
-                                s(:ivar, :@fetcher),
-                                s(:iasgn,
-                                  :@fetcher,
-                                  s(:call, nil, :new,
-                                    s(:call,
-                                      s(:call, s(:const, :Gem), :configuration),
-                                      :[],
-                                      s(:lit, :http_proxy))))))
-
-  add_tests("or",
-            "Ruby"         => "(a or b)",
-            "ParseTree"    => s(:or,
-                                s(:call, nil, :a),
-                                s(:call, nil, :b)))
-
-  add_tests("or_big",
-            "Ruby"         => "((a or b) or (c and d))",
-            "ParseTree"    => s(:or,
-                                s(:or,
-                                  s(:call, nil, :a),
-                                  s(:call, nil, :b)),
-                                s(:and,
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d))))
-
-  add_tests("or_big2",
-            "Ruby"         => "((a || b) || (c && d))",
-            "ParseTree"    => s(:or,
-                                s(:or,
-                                  s(:call, nil, :a),
-                                  s(:call, nil, :b)),
-                                s(:and,
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d))),
-            "Ruby2Ruby"    => "((a or b) or (c and d))")
-
-  add_tests("parse_floats_as_args",
-            "Ruby"         => "def x(a=0.0,b=0.0)\n  a+b\nend",
-            "ParseTree"    => s(:defn, :x,
-                                s(:args,
-                                  s(:lasgn, :a, s(:lit, 0.0)),
-                                  s(:lasgn, :b, s(:lit, 0.0))),
-                                s(:call, s(:lvar, :a), :+, s(:lvar, :b))),
-            "Ruby2Ruby"    => "def x(a = 0.0, b = 0.0)\n  (a + b)\nend")
-
-  add_tests("postexe",
-            "Ruby"         => "END { 1 }",
-            "ParseTree"    => s(:iter, s(:postexe), 0, s(:lit, 1)))
-
-  add_tests("proc_args_0",
-            "Ruby"         => "proc { || (x + 1) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :proc),
-                                s(:args),
-                                s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
-
-  add_tests("proc_args_1",
-            "Ruby"         => "proc { |x| (x + 1) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :proc),
-                                s(:args, :x),
-                                s(:call, s(:lvar, :x), :+, s(:lit, 1))))
-
-  add_tests("proc_args_2",
-            "Ruby"         => "proc { |x, y| (x + y) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :proc),
-                                s(:args, :x, :y),
-                                s(:call, s(:lvar, :x), :+, s(:lvar, :y))))
-
-  add_tests("proc_args_no",
-            "Ruby"         => "proc { (x + 1) }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :proc),
-                                0,
-                                s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
-
-  add_tests("redo",
-            "Ruby"         => "loop { redo if false }",
-            "ParseTree"    => s(:iter,
-                                s(:call, nil, :loop),
-                                0,
-                                s(:if, s(:false), s(:redo), nil)))
-
-  add_tests("rescue",  # TODO: need a resbody w/ multiple classes and a splat
-            "Ruby"         => "blah rescue nil",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :blah),
-                                s(:resbody, s(:array), s(:nil))))
-
-  add_tests("rescue_block_body",
-            "Ruby"         => "begin\n  a\nrescue => e\n  c\n  d\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :a),
-                                s(:resbody,
-                                  s(:array, s(:lasgn, :e, s(:gvar, :$!))),
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d))))
-
-  add_tests("rescue_block_body_3",
-            "Ruby"         => "begin\n  a\nrescue A\n  b\nrescue B\n  c\nrescue C\n  d\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :a),
-                                s(:resbody, s(:array, s(:const, :A)),
-                                  s(:call, nil, :b)),
-                                s(:resbody, s(:array, s(:const, :B)),
-                                  s(:call, nil, :c)),
-                                s(:resbody, s(:array, s(:const, :C)),
-                                  s(:call, nil, :d))))
-
-  add_tests("rescue_block_body_ivar",
-            "Ruby"         => "begin\n  a\nrescue => @e\n  c\n  d\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :a),
-                                s(:resbody,
-                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
-                                  s(:call, nil, :c),
-                                  s(:call, nil, :d))))
-
-  add_tests("rescue_block_nada",
-            "Ruby"         => "begin\n  blah\nrescue\n  # do nothing\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :blah),
-                                s(:resbody, s(:array), nil)))
-
-  add_tests("rescue_exceptions",
-            "Ruby"         => "begin\n  blah\nrescue RuntimeError => r\n  # do nothing\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:call, nil, :blah),
-                                s(:resbody,
-                                  s(:array,
-                                    s(:const, :RuntimeError),
-                                    s(:lasgn, :r, s(:gvar, :$!))),
-                                  nil)))
-
-  add_tests("rescue_iasgn_var_empty",
-            "Ruby"         => "begin\n  1\nrescue => @e\n  # do nothing\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:lit, 1),
-                                s(:resbody,
-                                  s(:array, s(:iasgn, :@e, s(:gvar, :$!))),
-                                  nil)))
-
-  add_tests("rescue_lasgn",
-            "Ruby"         => "begin\n  1\nrescue\n  var = 2\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:lit, 1),
-                                s(:resbody,
-                                  s(:array),
-                                  s(:lasgn, :var, s(:lit, 2)))),
-            "Ruby2Ruby"    => "1 rescue var = 2")
-
-  add_tests("rescue_lasgn_var",
-            "Ruby"         => "begin\n  1\nrescue => e\n  var = 2\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:lit, 1),
-                                s(:resbody,
-                                  s(:array, s(:lasgn, :e, s(:gvar, :$!))),
-                                  s(:lasgn, :var, s(:lit, 2)))))
-
-  add_tests("rescue_lasgn_var_empty",
-            "Ruby"         => "begin\n  1\nrescue => e\n  # do nothing\nend",
-            "ParseTree"    => s(:rescue,
-                                s(:lit, 1),
-                                s(:resbody,
-                                  s(:array, s(:lasgn, :e, s(:gvar, :$!))),
-                                  nil)))
-
-  add_tests("retry",
-            "Ruby"         => "retry",
-            "ParseTree"    => s(:retry))
-
-  add_tests("return_0",
-            "Ruby"         => "return",
-            "ParseTree"    => s(:return))
-
-  add_tests("return_1",
-            "Ruby"         => "return 1",
-            "ParseTree"    => s(:return, s(:lit, 1)))
-
-  add_tests("return_1_splatted",
-            "Ruby"         => "return *1",
-            "ParseTree"    => s(:return, s(:svalue, s(:splat, s(:lit, 1)))))
-
-  add_tests("return_n",
-            "Ruby"         => "return 1, 2, 3",
-            "ParseTree"    => s(:return, s(:array,
-                                           s(:lit, 1), s(:lit, 2), s(:lit, 3))),
-            "Ruby2Ruby"    => "return [1, 2, 3]")
-
-  add_tests("sclass",
-            "Ruby"         => "class << self\n  42\nend",
-            "ParseTree"    => s(:sclass, s(:self), s(:lit, 42)))
-
-  add_tests("sclass_multiple",
-            "Ruby"         => "class << self\n  x\n  y\nend",
-            "ParseTree"    => s(:sclass, s(:self),
-                                s(:call, nil, :x), s(:call, nil, :y)))
-
-  add_tests("sclass_trailing_class",
-            "Ruby"         => "class A\n  class << self\n    a\n  end\n  \n  class B\n  end\nend",
-            "ParseTree"    => s(:class, :A, nil,
-                                s(:sclass, s(:self),
-                                  s(:call, nil, :a)),
-                                s(:class, :B, nil)))
-
-  add_tests("splat",
-            "Ruby"         => "def x(*b)\n  a(*b)\nend",
-            "ParseTree"    => s(:defn, :x,
-                                s(:args, :"*b"),
-                                s(:call, nil, :a, s(:splat, s(:lvar, :b)))))
-
-  add_tests("splat_array",
-            "Ruby"         => "[*[1]]",
-            "ParseTree"    => s(:array, s(:splat, s(:array, s(:lit, 1)))))
-
-  add_tests("splat_break",
-            "Ruby"         => "break *[1]",
-            "ParseTree"    => s(:break, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_break_array",
-            "Ruby"         => "break [*[1]]",
-            "ParseTree"    => s(:break, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_fcall",
-            "Ruby"         => "meth(*[1])",
-            "ParseTree"    => s(:call,
-                                nil,
-                                :meth,
-                                s(:splat, s(:array, s(:lit, 1)))))
-
-  add_tests("splat_fcall_array",
-            "Ruby"         => "meth([*[1]])",
-            "ParseTree"    => s(:call, nil, :meth,
-                                s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_lasgn",
-            "Ruby"         => "x = *[1]",
-            "ParseTree"    => s(:lasgn, :x, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_lasgn_array",
-            "Ruby"         => "x = [*[1]]",
-            "ParseTree"    => s(:lasgn, :x, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_lit_1",
-            "Ruby"         => "[*1]",
-# UGH - damn MRI
-            "ParseTree"    => s(:array, s(:splat, s(:lit, 1))))
-
-  add_tests("splat_lit_n",
-            "Ruby"         => "[1, *2]",
-            "ParseTree"    => s(:array, s(:lit, 1), s(:splat, s(:lit, 2))))
-
-  add_tests("splat_next",
-            "Ruby"         => "next *[1]",
-            "ParseTree"    => s(:next, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_next_array",
-            "Ruby"         => "next [*[1]]",
-            "ParseTree"    => s(:next, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_return",
-            "Ruby"         => "return *[1]",
-            "ParseTree"    => s(:return, s(:svalue, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_return_array",
-            "Ruby"         => "return [*[1]]",
-            "ParseTree"    => s(:return, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_super",
-            "Ruby"         => "super(*[1])",
-            "ParseTree"    => s(:super, s(:splat, s(:array, s(:lit, 1)))))
-
-  add_tests("splat_super_array",
-            "Ruby"         => "super([*[1]])",
-            "ParseTree"    => s(:super, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("splat_yield",
-            "Ruby"         => "yield(*[1])",
-            "ParseTree"    => s(:yield, s(:splat, s(:array, s(:lit, 1)))))
-
-  add_tests("splat_yield_array",
-            "Ruby"         => "yield([*[1]])",
-            "ParseTree"    => s(:yield, s(:array, s(:splat, s(:array, s(:lit, 1))))))
-
-  add_tests("str",
-            "Ruby"         => '"x"',
-            "ParseTree"    => s(:str, "x"))
-
-  add_tests("str_concat_newline", # FIX? make prettier? possible?
-            "Ruby"         => '"before" \\
-  " after"',
-            "ParseTree"    => s(:str, "before after"),
-            "Ruby2Ruby"    => '"before after"')
-
-  add_tests("str_concat_space",
-            "Ruby"         => '"before" " after"',
-            "ParseTree"    => s(:str, "before after"),
-            "Ruby2Ruby"    => '"before after"')
-
-  add_tests("str_heredoc",
-            "Ruby"         => "<<'EOM'\n  blah\nblah\nEOM",
-            "ParseTree"    => s(:str, "  blah\nblah\n"),
-            "Ruby2Ruby"    => "\"  blah\\nblah\\n\"")
-
-  add_tests("str_heredoc_call",
-            "Ruby"         => "<<'EOM'.strip\n  blah\nblah\nEOM",
-            "ParseTree"    => s(:call, s(:str, "  blah\nblah\n"),
-                                :strip),
-            "Ruby2Ruby"    => "\"  blah\\nblah\\n\".strip")
-
-  add_tests("str_heredoc_double",
-            "Ruby"         => "a += <<-H1 + b + <<-H2\n  first\nH1\n  second\nH2",
-            "ParseTree"    => s(:lasgn, :a,
-                                s(:call,
-                                  s(:lvar, :a),
-                                  :+,
-                                  s(:call,
-                                    s(:call,
-                                      s(:str, "  first\n"),
-                                      :+,
-                                      s(:call, nil, :b)),
-                                    :+,
-                                    s(:str, "  second\n")))),
-            "Ruby2Ruby"    => "a = (a + ((\"  first\\n\" + b) + \"  second\\n\"))")
-
-  add_tests("str_heredoc_empty", # yes... tarded
-            "Ruby"         => "<<'EOM'\nEOM",
-            "ParseTree"    => s(:str, ""),
-            "Ruby2Ruby"    => '""')
-
-  add_tests("str_heredoc_indent",
-            "Ruby"         => "<<-EOM\n  blah\nblah\n\n  EOM",
-            "ParseTree"    => s(:str, "  blah\nblah\n\n"),
-            "Ruby2Ruby"    => "\"  blah\\nblah\\n\\n\"")
-
-  add_tests("str_interp_file",
-            "Ruby"         => '"file = #{__FILE__}\n"',
-            "ParseTree"    => s(:str, "file = (string)\n"),
-            "Ruby2Ruby"    => '"file = (string)\\n"')
-
-  add_tests("structure_extra_block_for_dvar_scoping",
-            "Ruby"         => "a.b do |c, d|\n  unless e.f(c) then\n    g = false\n    d.h { |x, i| g = true }\n  end\nend",
-            "ParseTree"    => s(:iter,
-                                s(:call, s(:call, nil, :a), :b),
-                                s(:args, :c, :d),
-                                s(:if,
-                                  s(:call, s(:call, nil, :e), :f, s(:lvar, :c)),
-                                  nil,
-                                  s(:block,
-                                    s(:lasgn, :g, s(:false)),
-                                    s(:iter,
-                                      s(:call, s(:lvar, :d), :h),
-                                      s(:args, :x, :i),
-                                      s(:lasgn, :g, s(:true)))))))
-
-  add_tests("structure_remove_begin_1",
-            "Ruby"         => "a << begin\n       b\n     rescue\n       c\n     end",
-            "ParseTree"    => s(:call, s(:call, nil, :a), :<<,
-                                s(:rescue,
-                                  s(:call, nil, :b),
-                                  s(:resbody, s(:array),
-                                    s(:call, nil, :c)))),
-            "Ruby2Ruby"    => "(a << (b rescue c))")
-
-  add_tests("structure_remove_begin_2",
-            "Ruby"         => "a = if c\n      begin\n        b\n      rescue\n        nil\n      end\n    end\na",
-            "ParseTree"    => s(:block,
-                                s(:lasgn,
-                                  :a,
-                                  s(:if, s(:call, nil, :c),
-                                    s(:rescue, s(:call, nil, :b),
-                                      s(:resbody,
-                                        s(:array), s(:nil))),
-                                    nil)),
-                                s(:lvar, :a)),
-            "Ruby2Ruby"    => "a = b rescue nil if c\na\n") # OMG that's awesome
-
-  add_tests("super_0",
-            "Ruby"         => "def x\n  super()\nend",
-            "ParseTree"    => s(:defn, :x, s(:args), s(:super)))
-
-  add_tests("super_1",
-            "Ruby"         => "def x\n  super(4)\nend",
-            "ParseTree"    => s(:defn, :x, s(:args),
-                                s(:super, s(:lit, 4))))
-
-  add_tests("super_1_array",
-            "Ruby"         => "def x\n  super([24, 42])\nend",
-            "ParseTree"    => s(:defn, :x, s(:args),
-                                s(:super, s(:array, s(:lit, 24), s(:lit, 42)))))
-
-  add_tests("super_block_pass",
-            "Ruby"         => "super(a, &b)",
-            "ParseTree"    => s(:super,
-                                s(:call, nil, :a),
-                                s(:block_pass,
-                                  s(:call, nil, :b))))
-
-  add_tests("super_block_splat",
-            "Ruby"         => "super(a, *b)",
-            "ParseTree"    => s(:super,
-                                s(:call, nil, :a),
-                                s(:splat, s(:call, nil, :b))))
-
-  add_tests("super_n",
-            "Ruby"         => "def x\n  super(24, 42)\nend",
-            "ParseTree"    => s(:defn, :x, s(:args),
-                                s(:super, s(:lit, 24), s(:lit, 42))))
-
-  add_tests("svalue",
-            "Ruby"         => "a = *b",
-            "ParseTree"    => s(:lasgn, :a,
-                                s(:svalue,
-                                  s(:splat, s(:call, nil, :b)))))
-
-  add_tests("ternary_nil_no_space",
-            "Ruby"         => "1 ? nil: 1",
-            "ParseTree"    => s(:if, s(:lit, 1), s(:nil), s(:lit, 1)),
-            "Ruby2Ruby"    => "1 ? (nil) : (1)")
-
-  add_tests("ternary_symbol_no_spaces",
-            "Ruby"         => "1?:x:1",
-            "ParseTree"    => s(:if, s(:lit, 1), s(:lit, :x), s(:lit, 1)),
-            "Ruby2Ruby"    => "1 ? (:x) : (1)")
-
-  add_tests("to_ary",
-            "Ruby"         => "a, b = c",
-            "ParseTree"    => s(:masgn,
-                                s(:array, s(:lasgn, :a), s(:lasgn, :b)),
-                                s(:to_ary, s(:call, nil, :c))))
-
-  add_tests("true",
-            "Ruby"         => "true",
-            "ParseTree"    => s(:true))
-
-  add_tests("undef",
-            "Ruby"         => "undef :x",
-            "ParseTree"    => s(:undef, s(:lit, :x)))
-
-  add_tests("undef_2",
-            "Ruby"         => "undef :x, :y",
-            "ParseTree"    => s(:block,
-                                s(:undef, s(:lit, :x)),
-                                s(:undef, s(:lit, :y))),
-            "Ruby2Ruby"    => "undef :x\nundef :y\n")
-
-  add_tests("undef_3",
-            "Ruby"         => "undef :x, :y, :z",
-            "ParseTree"    => s(:block,
-                                s(:undef, s(:lit, :x)),
-                                s(:undef, s(:lit, :y)),
-                                s(:undef, s(:lit, :z))),
-            "Ruby2Ruby"    => "undef :x\nundef :y\nundef :z\n")
-
-  add_tests("undef_block_1",
-            "Ruby"         => "f1\nundef :x\n", # TODO: don't like the extra return
-            "ParseTree"    => s(:block,
-                                s(:call, nil, :f1),
-                                s(:undef, s(:lit, :x))))
-
-  add_tests("undef_block_2",
-            "Ruby"         => "f1\nundef :x, :y",
-            "ParseTree"    => s(:block,
-                                s(:call, nil, :f1),
-                                s(:block,
-                                  s(:undef, s(:lit, :x)),
-                                  s(:undef, s(:lit, :y)))),
-            "Ruby2Ruby"    => "f1\n(undef :x\nundef :y)\n")
-
-  add_tests("undef_block_3",
-            "Ruby"         => "f1\nundef :x, :y, :z",
-            "ParseTree"    => s(:block,
-                                s(:call, nil, :f1),
-                                s(:block,
-                                  s(:undef, s(:lit, :x)),
-                                  s(:undef, s(:lit, :y)),
-                                  s(:undef, s(:lit, :z)))),
-            "Ruby2Ruby"    => "f1\n(undef :x\nundef :y\nundef :z)\n")
-
-  add_tests("undef_block_3_post",
-            "Ruby"         => "undef :x, :y, :z\nf2",
-            "ParseTree"    => s(:block,
-                                s(:undef, s(:lit, :x)),
-                                s(:undef, s(:lit, :y)),
-                                s(:undef, s(:lit, :z)),
-                                s(:call, nil, :f2)),
-            "Ruby2Ruby"    => "undef :x\nundef :y\nundef :z\nf2\n")
-
-  add_tests("undef_block_wtf",
-            "Ruby"         => "f1\nundef :x, :y, :z\nf2",
-            "ParseTree"    => s(:block,
-                                s(:call, nil, :f1),
-                                s(:block,
-                                  s(:undef, s(:lit, :x)),
-                                  s(:undef, s(:lit, :y)),
-                                  s(:undef, s(:lit, :z))),
-                                s(:call, nil, :f2)),
-            "Ruby2Ruby"    => "f1\n(undef :x\nundef :y\nundef :z)\nf2\n")
-
-  add_tests("unless_post",
-            "Ruby"         => "a unless b",
-            "ParseTree"    => s(:if, s(:call, nil, :b), nil,
-                                s(:call, nil, :a)))
-
-  add_tests("unless_pre",
-            "Ruby"         => "unless b then a end",
-            "ParseTree"    => s(:if, s(:call, nil, :b), nil,
-                                s(:call, nil, :a)),
-            "Ruby2Ruby"    => "a unless b")
-
-  add_tests("until_post",
-            "Ruby"         => "begin\n  (1 + 1)\nend until false",
-            "ParseTree"    => s(:until, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), false))
-
-  add_tests("until_pre",
-            "Ruby"         => "until false do\n  (1 + 1)\nend",
-            "ParseTree"    => s(:until, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), true))
-
-  add_tests("until_pre_mod",
-            "Ruby"         => "(1 + 1) until false",
-            "ParseTree"    => s(:until, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-            "Ruby2Ruby"    => "until false do\n  (1 + 1)\nend")
-
-  add_tests("valias",
-            "Ruby"         => "alias $y $x",
-            "ParseTree"    => s(:valias, :$y, :$x))
-
-  add_tests("vcall",
-            "Ruby"         => "method",
-            "ParseTree"    => s(:call, nil, :method))
-
-  add_tests("while_post",
-            "Ruby"         => "begin\n  (1 + 1)\nend while false",
-            "ParseTree"    => s(:while, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), false))
-
-  add_tests("while_post2",
-            "Ruby"         => "begin\n  (1 + 2)\n  (3 + 4)\nend while false",
-            "ParseTree"    => s(:while, s(:false),
-                                s(:block,
-                                  s(:call, s(:lit, 1), :+, s(:lit, 2)),
-                                  s(:call, s(:lit, 3), :+, s(:lit, 4))),
-                                false))
-
-  add_tests("while_pre",
-            "Ruby"         => "while false do\n  (1 + 1)\nend",
-            "ParseTree"    => s(:while, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), true))
-
-  add_tests("while_pre_mod",
-            "Ruby"         => "(1 + 1) while false",
-            "ParseTree"    => s(:while, s(:false),
-                                s(:call, s(:lit, 1), :+, s(:lit, 1)), true),
-            "Ruby2Ruby"    => "while false do\n  (1 + 1)\nend") # FIX can be one liner
-
-  add_tests("while_pre_nil",
-            "Ruby"         => "while false do\nend",
-            "ParseTree"    => s(:while, s(:false), nil, true))
-
-  add_tests("xstr",
-            "Ruby"         => "`touch 5`",
-            "ParseTree"    => s(:xstr, "touch 5"))
-
-  add_tests("yield_0",
-            "Ruby"         => "yield",
-            "ParseTree"    => s(:yield))
-
-  add_tests("yield_1",
-            "Ruby"         => "yield(42)",
-            "ParseTree"    => s(:yield, s(:lit, 42)))
-
-  add_tests("yield_array_0",
-            "Ruby"         => "yield([])",
-            "ParseTree"    => s(:yield, s(:array)))
-
-  add_tests("yield_array_1",
-            "Ruby"         => "yield([42])",
-            "ParseTree"    => s(:yield, s(:array, s(:lit, 42))))
-
-  add_tests("yield_array_n",
-            "Ruby"         => "yield([42, 24])",
-            "ParseTree"    => s(:yield, s(:array, s(:lit, 42), s(:lit, 24))))
-
-  add_tests("yield_n",
-            "Ruby"         => "yield(42, 24)",
-            "ParseTree"    => s(:yield, s(:lit, 42), s(:lit, 24)))
-
-  add_tests("zarray",
-            "Ruby"         => "a = []",
-            "ParseTree"    => s(:lasgn, :a, s(:array)))
-
-  add_tests("zsuper",
-            "Ruby"         => "def x\n  super\nend",
-            "ParseTree"    => s(:defn, :x, s(:args), s(:zsuper)))
-
-# TODO: discuss and decide which lit we like
-#   it "converts a regexp to an sexp" do
-#     "/blah/".to_sexp.should == s(:regex, "blah", 0)
-#     "/blah/i".to_sexp.should == s(:regex, "blah", 1)
-#     "/blah/u".to_sexp.should == s(:regex, "blah", 64)
-#   end
-
-end
-
-# :startdoc: