ParseTree 3.0.1-x86-mswin32-60

data/test/something.rb

@@ -0,0 +1,53 @@
+
+class Something
+
+  def self.classmethod
+    1 + 1
+  end
+
+  # Other edge cases:
+
+  def opt_args(arg1, arg2 = 42, *args)
+    arg3 = arg1 * arg2 * 7
+    puts(arg3.to_s)
+    return "foo"
+  end
+
+  def multi_args(arg1, arg2)
+    arg3 = arg1 * arg2 * 7
+    puts(arg3.to_s)
+    return "foo"
+  end
+
+  def unknown_args(arg1, arg2)
+    # does nothing
+    return arg1
+  end
+
+  def determine_args
+    5 == unknown_args(4, "known")
+  end
+
+  # TODO: sort list
+  def bbegin
+    begin
+      1
+    rescue SyntaxError => e1
+      2
+    rescue Exception => e2
+      3
+    else
+      4
+    ensure
+      5
+    end
+  end
+
+  def bbegin_no_exception
+    begin
+      5
+    rescue
+      6
+    end
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,13 @@
+#!/usr/local/bin/ruby -w
+
+pat = "test_*.rb"
+if File.basename(Dir.pwd) != "test" then
+  $: << "test"
+  pat = File.join("test", pat)
+end
+
+Dir.glob(pat).each do |f|
+  require f
+end
+
+require 'test/unit'

data/test/test_parse_tree.rb

@@ -0,0 +1,259 @@
+#!/usr/local/bin/ruby -w
+
+dir = File.expand_path "~/.ruby_inline"
+if test ?d, dir then
+  require 'fileutils'
+  puts "nuking #{dir}"
+  # force removal, Windoze is bitching at me, something to hunt later...
+  FileUtils.rm_r dir, :force => true
+end
+
+require 'test/unit'
+require 'parse_tree'
+require 'pt_testcase'
+require 'test/something'
+
+class SomethingWithInitialize
+  def initialize; end # this method is private
+  protected
+  def protected_meth; end
+end
+
+class RawParseTree
+  def process(input, verbose = nil) # TODO: remove
+
+    test_method = caller[0][/\`(.*)\'/, 1]
+    verbose = test_method =~ /mri_verbose_flag/ ? true : nil
+
+    # um. kinda stupid, but cleaner
+    case input
+    when Array then
+      ParseTree.translate(*input)
+    else
+      self.parse_tree_for_string(input, '(string)', 1, verbose).first
+    end
+  end
+end
+
+class TestRawParseTree < ParseTreeTestCase
+  def setup
+    super
+    @processor = RawParseTree.new(false)
+  end
+
+  def test_parse_tree_for_string_with_newlines
+    @processor = RawParseTree.new(true)
+    actual   = @processor.parse_tree_for_string "1 +\n nil", 'test.rb', 5
+    expected = [[:newline, 6, "test.rb",
+                 [:call, [:lit, 1], :+, [:array, [:nil]]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_class_initialize
+    expected = [[:class, :SomethingWithInitialize, [:const, :Object],
+      [:defn, :initialize, [:scope, [:block, [:args], [:nil]]]],
+      [:defn, :protected_meth, [:scope, [:block, [:args], [:nil]]]],
+    ]]
+    tree = @processor.parse_tree SomethingWithInitialize
+    assert_equal expected, tree
+  end
+
+  def test_class_translate_string
+    str = "class A; def a; end; end"
+
+    sexp = ParseTree.translate str
+
+    expected = [:class, :A, nil,
+                 [:scope,
+                   [:defn, :a, [:scope, [:block, [:args], [:nil]]]]]]
+
+    assert_equal expected, sexp
+  end
+
+  def test_class_translate_string_method
+    str = "class A; def a; end; def b; end; end"
+
+    sexp = ParseTree.translate str, :a
+
+    expected = [:defn, :a, [:scope, [:block, [:args], [:nil]]]]
+
+    assert_equal expected, sexp
+  end
+
+  def test_parse_tree_for_string
+    actual   = @processor.parse_tree_for_string '1 + nil', '(string)', 1
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  def test_parse_tree_for_str
+    actual   = @processor.parse_tree_for_str '1 + nil', '(string)', 1
+    expected = [[:call, [:lit, 1], :+, [:array, [:nil]]]]
+
+    assert_equal expected, actual
+  end
+
+  @@self_classmethod = [:defs,
+                        [:self], :classmethod,
+                        [:scope,
+                         [:block,
+                          [:args],
+                          [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]]]
+
+  @@missing = [nil]
+
+  @@opt_args = [:defn, :opt_args,
+    [:scope,
+      [:block,
+        [:args, :arg1, :arg2, :"*args", [:block, [:lasgn, :arg2, [:lit, 42]]]],
+        [:lasgn, :arg3,
+          [:call,
+            [:call,
+              [:lvar, :arg1],
+              :*,
+              [:array, [:lvar, :arg2]]],
+            :*,
+            [:array, [:lit, 7]]]],
+        [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+        [:return,
+          [:str, "foo"]]]]]
+
+  @@multi_args = [:defn, :multi_args,
+    [:scope,
+      [:block,
+        [:args, :arg1, :arg2],
+        [:lasgn, :arg3,
+          [:call,
+            [:call,
+              [:lvar, :arg1],
+              :*,
+              [:array, [:lvar, :arg2]]],
+            :*,
+            [:array, [:lit, 7]]]],
+        [:fcall, :puts, [:array, [:call, [:lvar, :arg3], :to_s]]],
+        [:return,
+          [:str, "foo"]]]]]
+
+  @@unknown_args = [:defn, :unknown_args,
+    [:scope,
+      [:block,
+        [:args, :arg1, :arg2],
+        [:return, [:lvar, :arg1]]]]]
+
+  @@bbegin = [:defn, :bbegin,
+    [:scope,
+      [:block,
+        [:args],
+        [:begin,
+          [:ensure,
+            [:rescue,
+              [:lit, 1],
+              [:resbody,
+                [:array, [:const, :SyntaxError]],
+                [:block, [:lasgn, :e1, [:gvar, :$!]], [:lit, 2]],
+                [:resbody,
+                  [:array, [:const, :Exception]],
+                  [:block, [:lasgn, :e2, [:gvar, :$!]], [:lit, 3]]]],
+              [:lit, 4]],
+            [:lit, 5]]]]]]
+  @@bbegin_no_exception = [:defn, :bbegin_no_exception,
+    [:scope,
+      [:block,
+        [:args],
+        [:begin,
+          [:rescue,
+            [:lit, 5],
+            [:resbody, nil, [:lit, 6]]]]]]]
+
+  @@determine_args = [:defn, :determine_args,
+    [:scope,
+      [:block,
+        [:args],
+          [:call,
+            [:lit, 5],
+            :==,
+            [:array,
+              [:fcall,
+                :unknown_args,
+                [:array, [:lit, 4], [:str, "known"]]]]]]]]
+
+  @@attrasgn = [:defn,
+    :attrasgn,
+    [:scope,
+      [:block,
+        [:args],
+        [:attrasgn, [:lit, 42], :method=, [:array, [:vcall, :y]]],
+        [:attrasgn,
+          [:self],
+          :type=,
+          [:array, [:call, [:vcall, :other], :type]]]]]]
+
+  @@__all = [:class, :Something, [:const, :Object]]
+
+  Something.instance_methods(false).sort.each do |meth|
+    if class_variables.include?("@@#{meth}") then
+      @@__all << eval("@@#{meth}")
+      eval "def test_#{meth}; assert_equal @@#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, false, false); end"
+    else
+      eval "def test_#{meth}; flunk \"You haven't added @@#{meth} yet\"; end"
+    end
+  end
+
+  Something.singleton_methods.sort.each do |meth|
+    next if meth =~ /yaml/ # rubygems introduced a bug
+    if class_variables.include?("@@self_#{meth}") then
+      @@__all << eval("@@self_#{meth}")
+      eval "def test_self_#{meth}; assert_equal @@self_#{meth}, @processor.parse_tree_for_method(Something, :#{meth}, true); end"
+    else
+      eval "def test_self_#{meth}; flunk \"You haven't added @@self_#{meth} yet\"; end"
+    end
+  end
+
+  def test_missing
+    assert_equal(@@missing,
+                 @processor.parse_tree_for_method(Something, :missing),
+                 "Must return #{@@missing.inspect} for missing methods")
+  end
+
+  def test_whole_class
+    assert_equal([@@__all],
+                 @processor.parse_tree(Something),
+                 "Must return a lot of shit")
+  end
+end
+
+class TestParseTree < ParseTreeTestCase
+  def setup
+    super
+    @processor = ParseTree.new(false)
+  end
+
+  def test_process_string
+    actual   = @processor.process '1 + nil'
+    expected = s(:call, s(:lit, 1), :+, s(:arglist, s(:nil)))
+
+    assert_equal expected, actual
+
+    actual   = @processor.process 'puts 42'
+    expected = s(:call, nil, :puts, s(:arglist, s(:lit, 42)))
+
+    assert_equal expected, actual
+  end
+
+  def test_process_string_newlines
+    @processor = ParseTree.new(true)
+    actual   = @processor.process "1 +\n nil", false, 'test.rb', 5
+    expected = s(:newline, 6, "test.rb",
+                 s(:call, s(:lit, 1), :+, s(:arglist, s(:nil))))
+
+    assert_equal expected, actual
+  end
+
+  # TODO: test_process_proc ?
+  # TODO: test_process_method ?
+  # TODO: test_process_class ?
+  # TODO: test_process_module ?
+
+end

data/test/test_parse_tree_extensions.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'parse_tree'
+require 'parse_tree_extensions'
+require 'tmpdir'
+
+$: << "../../ruby2ruby/dev/lib" # unoffical dependency - user responsibility
+require 'ruby2ruby'
+
+class R2RTestCase < Test::Unit::TestCase
+  def test_proc_to_ruby
+    util_setup_inline
+    block = proc { puts "something" }
+    assert_equal 'proc { puts("something") }', block.to_ruby
+  end
+
+  def test_proc_to_sexp
+    util_setup_inline
+    p = proc { 1 + 1 }
+    s = s(:iter,
+          s(:call, nil, :proc, s(:arglist)),
+          nil,
+          s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))
+    assert_equal s, p.to_sexp
+  end
+
+  def test_unbound_method_to_ruby
+    util_setup_inline
+    r = "proc { ||\n  util_setup_inline\n  p = proc { (1 + 1) }\n  s = s(:iter, s(:call, nil, :proc, s(:arglist)), nil, s(:call, s(:lit, 1), :+, s(:arglist, s(:lit, 1))))\n  assert_equal(s, p.to_sexp)\n}"
+    m = self.class.instance_method(:test_proc_to_sexp)
+
+    assert_equal r, m.to_ruby
+  end
+
+  def util_setup_inline
+    @rootdir = File.join(Dir.tmpdir, "test_ruby_to_ruby.#{$$}")
+    Dir.mkdir @rootdir, 0700 unless test ?d, @rootdir
+    ENV['INLINEDIR'] = @rootdir
+  end
+end

data/test/test_unified_ruby.rb

@@ -0,0 +1,315 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'test/unit' if $0 == __FILE__ unless defined? $ZENTEST and $ZENTEST
+require 'test/unit/testcase'
+require 'sexp'
+require 'sexp_processor'
+require 'unified_ruby'
+require 'pt_testcase'
+
+class TestUnifier < SexpProcessor
+  include UnifiedRuby
+end
+
+# (old) TODO:
+#
+# 1) DONE [vf]call => call
+# 2) DONE defn scope block args -> defn args scope block
+# 3) DONE [bd]method/fbody => defn
+# 4) rescue cleanup
+# 5) defs x -> defn self.x # ON HOLD
+# 6) ? :block_arg into args list?
+
+# ParseTreeTestCase.testcase_order << "UnifiedRuby"
+# class TestUnifiedRuby < ParseTreeTestCase
+#   def setup
+#     super
+#     @processor = TestUnifier.new
+#   end
+# end
+
+#   add_test("alias", :skip)
+#   add_test("alias_ugh", :skip)
+#   add_test("and", :skip)
+#   add_test("argscat_inside", :skip)
+#   add_test("argscat_svalue", :skip)
+#   add_test("argspush", :skip)
+#   add_test("array", :skip)
+#   add_test("array_pct_W", :skip)
+#   add_test("attrasgn", :skip)
+#   add_test("attrasgn_index_equals", :skip)
+#   add_test("attrasgn_index_equals_space", :skip)
+#   add_test("attrset", :skip)
+#   add_test("back_ref", :skip)
+#   add_test("begin", :skip)
+#   add_test("begin_def", :skip)
+#   add_test("begin_rescue_ensure", :skip)
+#   add_test("begin_rescue_twice", :skip)
+#   add_test("block_lasgn", :skip)
+#   add_test("block_mystery_block", :skip)
+#   add_test("block_pass_args_and_splat", :skip)
+#   add_test("block_pass_call_0", :skip)
+#   add_test("block_pass_call_1", :skip)
+#   add_test("block_pass_call_n", :skip)
+#   add_test("block_pass_fcall_0", :skip)
+#   add_test("block_pass_fcall_1", :skip)
+#   add_test("block_pass_fcall_n", :skip)
+#   add_test("block_pass_omgwtf", :skip)
+#   add_test("block_pass_splat", :skip)
+#   add_test("block_pass_thingy", :skip)
+#   add_test("block_stmt_after", :skip)
+#   add_test("block_stmt_before", :skip)
+#   add_test("block_stmt_both", :skip)
+#   add_test("bmethod", :skip)
+#   add_test("bmethod_noargs", :skip)
+#   add_test("bmethod_splat", :skip)
+#   add_test("break", :skip)
+#   add_test("break_arg", :skip)
+#   add_test("call", :skip)
+#   add_test("call_arglist", :skip)
+#   add_test("call_arglist_hash", :skip)
+#   add_test("call_arglist_norm_hash", :skip)
+#   add_test("call_arglist_norm_hash_splat", :skip)
+#   add_test("call_command", :skip)
+#   add_test("call_expr", :skip)
+#   add_test("call_index", :skip)
+#   add_test("call_index_no_args", :skip)
+#   add_test("call_index_space", :skip)
+#   add_test("call_unary_neg", :skip)
+#   add_test("case", :skip)
+#   add_test("case_nested", :skip)
+#   add_test("case_nested_inner_no_expr", :skip)
+#   add_test("case_no_expr", :skip)
+#   add_test("case_splat", :skip)
+#   add_test("cdecl", :skip)
+#   add_test("class_plain", :skip)
+#   add_test("class_scoped", :skip)
+#   add_test("class_scoped3", :skip)
+#   add_test("class_super_array", :skip)
+#   add_test("class_super_expr", :skip)
+#   add_test("class_super_object", :skip)
+#   add_test("colon2", :skip)
+#   add_test("colon3", :skip)
+#   add_test("conditional1", :skip)
+#   add_test("conditional2", :skip)
+#   add_test("conditional3", :skip)
+#   add_test("conditional4", :skip)
+#   add_test("conditional5", :skip)
+#   add_test("conditional_post_if", :skip)
+#   add_test("conditional_post_if_not", :skip)
+#   add_test("conditional_post_unless", :skip)
+#   add_test("conditional_post_unless_not", :skip)
+#   add_test("conditional_pre_if", :skip)
+#   add_test("conditional_pre_if_not", :skip)
+#   add_test("conditional_pre_unless", :skip)
+#   add_test("conditional_pre_unless_not", :skip)
+#   add_test("const", :skip)
+#   add_test("constX", :skip)
+#   add_test("constY", :skip)
+#   add_test("constZ", :skip)
+#   add_test("cvar", :skip)
+#   add_test("cvasgn", :skip)
+#   add_test("cvasgn_cls_method", :skip)
+#   add_test("cvdecl", :skip)
+#   add_test("dasgn_0", :skip)
+#   add_test("dasgn_1", :skip)
+#   add_test("dasgn_2", :skip)
+#   add_test("dasgn_curr", :skip)
+#   add_test("dasgn_icky", :skip)
+#   add_test("dasgn_mixed", :skip)
+#   add_test("defined", :skip)
+#   add_test("defn_args_mand_opt_block", :skip)
+#   add_test("defn_args_mand_opt_splat", :skip)
+#   add_test("defn_args_mand_opt_splat_block", :skip)
+#   add_test("defn_args_mand_opt_splat_no_name", :skip)
+#   add_test("defn_args_opt_block", :skip)
+#   add_test("defn_args_opt_splat_no_name", :skip)
+#   add_test("defn_empty", :skip)
+#   add_test("defn_empty_args", :skip)
+#   add_test("defn_lvar_boundary", :skip)
+#   add_test("defn_optargs", :skip)
+#   add_test("defn_or", :skip)
+#   add_test("defn_rescue", :skip)
+#   add_test("defn_something_eh", :skip)
+#   add_test("defn_splat_no_name", :skip)
+#   add_test("defn_zarray", :skip)
+#   add_test("defs", :skip)
+#   add_test("defs_args_mand_opt_splat_block", :skip)
+#   add_test("defs_empty", :skip)
+#   add_test("defs_empty_args", :skip)
+#   add_test("dmethod", :skip)
+#   add_test("dot2", :skip)
+#   add_test("dot3", :skip)
+#   add_test("dregx", :skip)
+#   add_test("dregx_interp", :skip)
+#   add_test("dregx_n", :skip)
+#   add_test("dregx_once", :skip)
+#   add_test("dregx_once_n_interp", :skip)
+#   add_test("dstr", :skip)
+#   add_test("dstr_2", :skip)
+#   add_test("dstr_3", :skip)
+#   add_test("dstr_concat", :skip)
+#   add_test("dstr_heredoc_expand", :skip)
+#   add_test("dstr_heredoc_windoze_sucks", :skip)
+#   add_test("dstr_heredoc_yet_again", :skip)
+#   add_test("dstr_nest", :skip)
+#   add_test("dstr_str_lit_start", :skip)
+#   add_test("dstr_the_revenge", :skip)
+#   add_test("dsym", :skip)
+#   add_test("dxstr", :skip)
+#   add_test("ensure", :skip)
+#   add_test("false", :skip)
+#   add_test("fbody", :skip)
+#   add_test("fcall_arglist", :skip)
+#   add_test("fcall_arglist_hash", :skip)
+#   add_test("fcall_arglist_norm_hash", :skip)
+#   add_test("fcall_arglist_norm_hash_splat", :skip)
+#   add_test("fcall_block", :skip)
+#   add_test("fcall_index_space", :skip)
+#   add_test("fcall_keyword", :skip)
+#   add_test("flip2", :skip)
+#   add_test("flip2_method", :skip)
+#   add_test("flip3", :skip)
+#   add_test("for", :skip)
+#   add_test("for_no_body", :skip)
+#   add_test("gasgn", :skip)
+#   add_test("global", :skip)
+#   add_test("gvar", :skip)
+#   add_test("gvar_underscore", :skip)
+#   add_test("gvar_underscore_blah", :skip)
+#   add_test("hash", :skip)
+#   add_test("hash_rescue", :skip)
+#   add_test("iasgn", :skip)
+#   add_test("if_block_condition", :skip)
+#   add_test("if_lasgn_short", :skip)
+#   add_test("iteration1", :skip)
+#   add_test("iteration2", :skip)
+#   add_test("iteration3", :skip)
+#   add_test("iteration4", :skip)
+#   add_test("iteration5", :skip)
+#   add_test("iteration6", :skip)
+#   add_test("iteration7", :skip)
+#   add_test("iteration8", :skip)
+#   add_test("iteration9", :skip)
+#   add_test("iteration_dasgn_curr_dasgn_madness", :skip)
+#   add_test("iteration_double_var", :skip)
+#   add_test("iteration_masgn", :skip)
+#   add_test("ivar", :skip)
+#   add_test("lasgn_array", :skip)
+#   add_test("lasgn_call", :skip)
+#   add_test("lit_bool_false", :skip)
+#   add_test("lit_bool_true", :skip)
+#   add_test("lit_float", :skip)
+#   add_test("lit_long", :skip)
+#   add_test("lit_long_negative", :skip)
+#   add_test("lit_range2", :skip)
+#   add_test("lit_range3", :skip)
+#   add_test("lit_regexp", :skip)
+#   add_test("lit_regexp_i_wwtt", :skip)
+#   add_test("lit_regexp_n", :skip)
+#   add_test("lit_regexp_once", :skip)
+#   add_test("lit_sym", :skip)
+#   add_test("lit_sym_splat", :skip)
+#   add_test("lvar_def_boundary", :skip)
+#   add_test("masgn", :skip)
+#   add_test("masgn_argscat", :skip)
+#   add_test("masgn_attrasgn", :skip)
+#   add_test("masgn_iasgn", :skip)
+#   add_test("masgn_masgn", :skip)
+#   add_test("masgn_splat", :skip)
+#   add_test("masgn_splat_no_name_to_ary", :skip)
+#   add_test("masgn_splat_no_name_trailing", :skip)
+#   add_test("masgn_splat_to_ary", :skip)
+#   add_test("masgn_splat_to_ary2", :skip)
+#   add_test("match", :skip)
+#   add_test("match2", :skip)
+#   add_test("match3", :skip)
+#   add_test("module", :skip)
+#   add_test("module_scoped", :skip)
+#   add_test("module_scoped3", :skip)
+#   add_test("next", :skip)
+#   add_test("next_arg", :skip)
+#   add_test("not", :skip)
+#   add_test("nth_ref", :skip)
+#   add_test("op_asgn1", :skip)
+#   add_test("op_asgn2", :skip)
+#   add_test("op_asgn2_self", :skip)
+#   add_test("op_asgn_and", :skip)
+#   add_test("op_asgn_and_ivar2", :skip)
+#   add_test("op_asgn_or", :skip)
+#   add_test("op_asgn_or_block", :skip)
+#   add_test("op_asgn_or_ivar", :skip)
+#   add_test("op_asgn_or_ivar2", :skip)
+#   add_test("or", :skip)
+#   add_test("or_big", :skip)
+#   add_test("or_big2", :skip)
+#   add_test("parse_floats_as_args", :skip)
+#   add_test("postexe", :skip)
+#   add_test("proc_args_0", :skip)
+#   add_test("proc_args_1", :skip)
+#   add_test("proc_args_2", :skip)
+#   add_test("proc_args_no", :skip)
+#   add_test("redo", :skip)
+#   add_test("rescue", :skip)
+#   add_test("rescue_block_body", :skip)
+#   add_test("rescue_block_nada", :skip)
+#   add_test("rescue_exceptions", :skip)
+#   add_test("retry", :skip)
+#   add_test("return_0", :skip)
+#   add_test("return_1", :skip)
+#   add_test("return_n", :skip)
+#   add_test("sclass", :skip)
+#   add_test("sclass_trailing_class", :skip)
+#   add_test("splat", :skip)
+#   add_test("str", :skip)
+#   add_test("str_concat_newline", :skip)
+#   add_test("str_concat_space", :skip)
+#   add_test("str_heredoc", :skip)
+#   add_test("str_heredoc_call", :skip)
+#   add_test("str_heredoc_double", :skip)
+#   add_test("str_heredoc_indent", :skip)
+#   add_test("str_interp_file", :skip)
+#   add_test("structure_extra_block_for_dvar_scoping", :skip)
+#   add_test("structure_remove_begin_1", :skip)
+#   add_test("structure_remove_begin_2", :skip)
+#   add_test("structure_unused_literal_wwtt", :skip)
+#   add_test("super", :skip)
+#   add_test("super_block_pass", :skip)
+#   add_test("super_block_splat", :skip)
+#   add_test("super_multi", :skip)
+#   add_test("svalue", :skip)
+#   add_test("to_ary", :skip)
+#   add_test("true", :skip)
+#   add_test("undef", :skip)
+#   add_test("undef_2", :skip)
+#   add_test("undef_3", :skip)
+#   add_test("undef_block_1", :skip)
+#   add_test("undef_block_2", :skip)
+#   add_test("undef_block_3", :skip)
+#   add_test("undef_block_3_post", :skip)
+#   add_test("undef_block_wtf", :skip)
+#   add_test("until_post", :skip)
+#   add_test("until_post_not", :skip)
+#   add_test("until_pre", :skip)
+#   add_test("until_pre_mod", :skip)
+#   add_test("until_pre_not", :skip)
+#   add_test("until_pre_not_mod", :skip)
+#   add_test("valias", :skip)
+#   add_test("vcall", :skip)
+#   add_test("while_post", :skip)
+#   add_test("while_post_not", :skip)
+#   add_test("while_pre", :skip)
+#   add_test("while_pre_mod", :skip)
+#   add_test("while_pre_nil", :skip)
+#   add_test("while_pre_not", :skip)
+#   add_test("while_pre_not_mod", :skip)
+#   add_test("xstr", :skip)
+#   add_test("yield", :skip)
+#   add_test("yield_arg", :skip)  # TODO: make it always have an argslist
+#   add_test("yield_args", :skip) # TODO: array -> argslist
+#   add_test("zarray", :skip)
+#   add_test("zsuper", :skip)
+# end
+