redparse 0.8.4 → 1.0.0

data/test/test_all.rb

@@ -1,3 +1,22 @@
-require 'test/test_redparse'
-#require 'test/test_xform_tree' #these are broken, gyaaah, not actually used
-#require 'test/test_1.9'  #should be enabled eventually, too many broken cases for now
+=begin copyright
+    redparse - a ruby parser written in ruby
+    Copyright (C) 2008,2009, 2012, 2016  Caleb Clausen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+$:.push File.expand_path(File.dirname(__FILE__))
+require 'test_redparse'
+#require 'test_xform_tree' #these are broken, gyaaah, not actually used
+require 'test_1.9'  #should be enabled eventually, too many broken cases for now

data/test/test_part.rb

@@ -0,0 +1,32 @@
+=begin copyright
+    redparse - a ruby parser written in ruby
+    Copyright (C) 2008,2009, 2012, 2016  Caleb Clausen
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+$:.push File.expand_path(File.dirname(__FILE__))
+require 'test_redparse'
+
+HASH=(ENV['PART']||0).to_i 
+ObjectSpace.each_object(Class){|k|
+  next unless k<=Test::Unit::TestCase
+  kn=k.name
+  k.instance_methods.each{|m| mm=m.to_s
+    if /^test_/===mm and (mm+kn).hash.&(0xFF) != HASH
+      k.instance_eval{undef_method(m.to_sym)} 
+    end
+  }
+}
+

data/test/test_redparse.rb

@@ -1,6 +1,6 @@
-=begin           
+=begin copyright
     redparse - a ruby parser written in ruby
-    Copyright (C) 2008  Caleb Clausen
+    Copyright (C) 2008, 2012, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -19,7 +19,77 @@
 
 $VERBOSE=1
 $Debug=1
+
 require 'test/unit'
+
+if ENV['MULTIPROCESS'] #or ENV['MANGLE']
+def (Test::Unit).run?; true end #the sense of this flag is inverted
+  filters=(0..0xFF).map{|h|
+    #exit Test::Unit::AutoRunner.run{|r| r.filters<<
+     proc{|tc| tc.method_name.+(tc.class.name).hash&0xFF==h} #}
+  }
+Test::Unit::AutoRunner.run{|r| r.filters<<filters.pop }
+at_exit do
+
+  workers=[]
+
+  sock2idx={}
+  results=[]
+  10.times{
+    si,co=IO.pipe
+    so,ci=IO.pipe
+    sock2idx[ci]=workers.size
+    workers<<co
+    results<<ci
+    fork{
+      #co.close
+      #ci.close
+      r=si
+      while l=r.gets
+        i=l.to_i
+        begin
+          p :autorunner
+          Test::Unit::AutoRunner.run{|r| r.filters<<filters[i] }
+        rescue Exception=>e
+          puts "ar error!"
+          so.puts "error: #{e.message}\t#{e.backtrace.join(%<\t>)}".gsub("\n","\t")
+        else
+          puts "ar done"
+          so.puts 'done'
+        end
+      end
+      exit!
+    }
+    #si.close
+    #so.close
+    filters.pop
+    co.puts filters.size.to_s
+  }
+  until filters.empty?
+    readable,=IO.select(results)
+    p readable
+    readable.each{|rd|
+      l=rd.gets
+      if /\Aerror: /===l
+        l[0,7]=''
+        l.gsub!("\t","\n")
+        warn "exception in autorunner instance:"
+        warn l
+      elsif /\Adone\Z/===l
+        sockidx=sock2idx[rd]
+        filter=filters.pop
+        i=filters.size
+        workers[sockidx].puts i.to_s
+      else fail "expected done or error in: '#{l.chomp}'"
+      end
+    }
+  end
+  readable.each{|rd| rd.close}
+
+  exit
+end
+end
+
 #require 'parse_tree'
 require 'tempfile'
 begin
@@ -31,21 +101,53 @@ end
 require "redparse"
 require "redparse/pthelper"
 require "rubylexer/test/testcases"
+require File.expand_path(__FILE__+"/../data/pt_known_output")
+require_relative 'ptlog' if ENV['PTLOG']
 
 $VERBOSE=1
 
+begin
+require 'test/unit/ui/console/testrunner'
+class Test::Unit::UI::Console::TestRunner
+  @@Extra_Summarizers=[]
+  alias finished__without_extra_summaries finished
+  def finished x
+    print "\nTests complete\n"
+    @@Extra_Summarizers.each{|sz| sz[x] }
+    finished__without_extra_summaries x
+  end
+  def self.extra_summary &code
+    @@Extra_Summarizers<<code
+  end
+end
+class Test::Unit::TestCase
+  def extra_summary &code
+    Test::Unit::UI::Console::TestRunner.extra_summary &code
+  end
+end
+rescue LoadError
+class Test::Unit::TestCase
+  def extra_summary &code
+    at_exit &code
+  end
+end
+end
+
 class Test::Unit::TestCase
-  def known_error
+  def known_error x
     from=caller.first
     from=from[/ in `.*'\Z/] || from[/\A[^:]*:[^:]*/]
-    yield
+    yield x
   rescue Test::Unit::AssertionFailedError=>e
     warn "an expected error occurred in #{from}: #{e.message}"
     if defined? @@known_errors
-      @@known_errors+=1
+      @@known_errors<<x
     else
-      @@known_errors=1
-      at_exit {warn "!!!UNFIXED KNOWN ERRORS!!!: #@@known_errors"}
+      @@known_errors=[x]
+      extra_summary {
+        warn "!!!UNFIXED KNOWN ERRORS!!!: #{@@known_errors.size}"
+        @@known_errors.each{|err| warn "  "+err unless err["\n"] }
+      }
     end
   rescue Exception=>e
     raise
@@ -55,21 +157,21 @@ class Test::Unit::TestCase
       @@known_errors_fixed+=1
     else
       @@known_errors_fixed=1
-      at_exit {warn "unexpectedly fixed known errors: #@@known_errors_fixed"}
+      extra_summary {warn "unexpectedly fixed known errors: #@@known_errors_fixed"}
     end
   end
 
-  def known_failure
+  def known_failure x
     from=caller.first
     from=from[/ in `.*'\Z/] || from[/\A[^:]*:[^:]*/]
-    yield
+    yield x
   rescue Exception=>e
     warn "an expected failure occurred in #{from}: #{e}"
     if defined? @@known_failures
       @@known_failures+=1
     else
       @@known_failures=1
-      at_exit {warn "!!!UNFIXED KNOWN FAILURES!!!: #@@known_failures"}
+      extra_summary {warn "!!!UNFIXED KNOWN FAILURES!!!: #@@known_failures"}
     end
   else
     warn "expected failure in #{from}, but was fixed(?!)"
@@ -77,24 +179,25 @@ class Test::Unit::TestCase
       @@known_failures_fixed+=1
     else
       @@known_failures_fixed=1
-      at_exit {warn "unexpectedly fixed known failures: #@@known_failures_fixed"}
+      extra_summary {warn "unexpectedly fixed known failures: #@@known_failures_fixed"}
     end
   end
 
-  def slow
+  def slow x
     if ENV['SLOW']
-      yield
+      yield x
     else
       if defined? @@slow_spots
         @@slow_spots+=1
       else
         @@slow_spots=1
-        at_exit {warn "slow test code skipped in #@@slow_spots places. (set SLOW to enable)"}
+        extra_summary {warn "slow test code skipped in #@@slow_spots places. (set SLOW to enable)"}
       end
     end
   end
 end
 
+if ENV['IMMED']
 #print output immediately on failing test (at end too....)
 begin
   require 'test/unit/ui/console/testrunner'
@@ -117,7 +220,7 @@ class MiniTest::Unit
     return result
   end
 end if defined? MiniTest::Unit
-
+end
 
 =begin nice idea, don't work yet
 class Test::Unit::TestResult
@@ -169,7 +272,9 @@ end
 =end
 
 require 'redparse/parse_tree_server'
-class ParseTree
+class ParseTree #todo: move this to parse_tree_server.rb. 
+                #also, slight fork of 
+                #parse_tree_and_warnings_leaks_stderr in bin/parsetree
   class<<self
   include ParseTreeComm
   def old_fork_server?
@@ -250,7 +355,7 @@ class ParseTree
     rescue Exception
       return nil,nil
     end
-    raise tree if Exception===tree
+    #raise tree if Exception===tree
     return tree,warnings
   end
   end
@@ -296,8 +401,9 @@ class RedParseTest<Test::Unit::TestCase
   FAILURE_EXAMPLES=[
   ]
   RUBYBUG_EXAMPLES=[
-
     #bugs in ruby itself
+    "a=a i? -R",
+    "b=1;b p %s[jim];",
     "c do p (110).m end",
     "p = p m %(1)",
     "p = p m %(1) ,&t",
@@ -308,6 +414,7 @@ class RedParseTest<Test::Unit::TestCase
     "z{|| p (1).m}",
 
     #bugs in ParseTree
+    'def a c=d=1; end',
 '    case
     when 0
       guecoding
@@ -334,12 +441,23 @@ class RedParseTest<Test::Unit::TestCase
     'c while d and /8/..2.a?(b)',
     'c while d and /8/../2.a?(b)/',
     'a if 1..2',
+    'status, err_args = Documeh_status{fcgi_state = 3; docespond do doc_response =fcgi_state =  1; end }',
+    "case;when I; JIS;else case; when sjis__length; EJP ;else 55; end;end",
+    "case;when 0;ng = 'JIS';else case; when sjis__length; ding = 'EUC-JP' ;end;end",
+    "doc_status, err_args = Documeh_status{fcgi_state = 3; docespond do doc_response =fcgi_state =  1; end }",
 
     #not sure which, doesn't really matter anyway
     "$11111111111111111111111111111111111111111111111111111111111111111111",
+    "module Array ([Array]).first::E include M end",
+    "module Array ([Array]).first::E include M; end",
+    "module Array ([Array]).first::E; end",
   ]
 
   ONELINERS=[
+    'TRUE'...'',
+    'FALSE'...'',
+    'NIL'...'',
+    'n||u n'...'',
     'yield [a_i, *p] '...'',
     '0.113725'...'',
     '0.777777'...'',
@@ -356,7 +474,7 @@ class RedParseTest<Test::Unit::TestCase
     'module self::A include B; c end'...'',
     'class a.b.c.d.e.f::Quux; YYY=534 end'...'',
     'class[Array][0]::Foo; Bazz=556 end'...'',
-    '=begin\r\nfoo\r\n=end\r\n'...'',
+    "=begin\r\nfoo\r\n=end\r\n"...'',
     'a!`b'...'',
     'fetch_named { {} }'...'',
     'def subject::Builder.foo; bar end'...'',
@@ -1610,7 +1728,8 @@ class RedParseTest<Test::Unit::TestCase
     '%W[a #{b} c]'...'',
 
     '"a b c #{d}"'...'',
-    '"a b c #{d}\n"'...'',
+    '"a b c #{d}\\n"'...'',
+    %*"a b c \#{d}\n"*...'',
     '"a b c #{d} "'...'',
     '"#{a} b c"'...'',
 
@@ -2856,7 +2975,91 @@ class RedParseTest<Test::Unit::TestCase
       "$-\v"...'',
       '$-[]'...'',
       'a,b=(*c=b,a)'...'',
-      
+      '"__A#{a=b,c=d}"'...'',
+      '"#{ * =f,g}"'...'',
+      '"#{*a0 = (*a= c)}"'...'',
+      '"#{*a0= begin a end rescue b0}"'...'',
+      '"#{*a=b rescue c}"'...'',
+      '"#{*a=b}"'...'',
+      '"#{*a[*b]=c}"'...'',
+      '"#{BEGIN{a}}"'...'',
+      '"#{END{a}}"'...'',
+      '"#{a=b,d rescue c}"'...'',
+      '"#{begin begin; ync; p1; end;rr end}"'...'',
+      '"1#{begin; r; t end;p (1).m}2"'...'',
+      'a=a i? -R'...'',
+      'begin; r; t end;q p'...'',
+      'begin; p (1..10).method(:each); rescue b; end.m'...'',
+      'begin; p (1..10).method(:each); rescue B=>c; end'...'',
+      'begin begin; ync; p1; end;rr end'...'',
+      '"#{"#{*a0 = (*a= c)}"}"'...'',
+      '"#{ * =f,g}"'...'',
+      'b=1;b p %s[jim];'...'',
+      '"#{*a=b}"'...'',
+      'a0 rescue b0=b,d rescue c'...'',
+      'a0 = ~begin; a; rescue b; end rescue b0'...'',
+      'def a c=d=1; end'...'',
+      '"#{a=1,2}"'...'',
+      '"#{a,=1}"'...'',
+      'a0 = ("#{a=b,d rescue c}") rescue b0'...'',
+      'a.b[]=a=b,c=d'...'',
+      'a rescue begin; p (1..10).method(:each); rescue b; end.m'...'',
+      'a rescue a=1,2 rescue 4'...'',
+      'a rescue a=*b rescue c rescue d'...'',
+      'a rescue BEGIN {a}'...'',
+      'a rescue "#{a=b,d rescue c}"'...'',
+      '__END__  #with a comment'...'',
+      '"sdfgfg#{"dfgdh"}";g'...'',
+      '+ ?c;p'...'',
+      '+?c;p'...'',
+      '+:s;p'...'',
+      "+:'s';p"...'',
+      '+/r/;p'...'',
+      '+"r";p'...'',
+      '+++++++++++1;p'...'',
+      '+++++++++++-1;p'...'',
+      '+%s{s};p'...'',
+      '* =f,g rescue b and c'...'',
+      '(begin; r; t end;b;c);d;e;f;(g;h;i)'...'',
+      '(BEGIN {})'...'',
+      '(;1;2;);p'...'',
+      '(/ 1/);p'...'',
+      '(mkk,(a=b,c).kk)=3'...'',
+      '"#{a=b,d rescue c}"'...'', 
+      "\r\n\n__END__\n\r\n\r\n\r\n\r\n\r\n"...'',
+      "%\n__END__\n[a]"...'',
+      "?\\\n__END__\n-?"...'',
+      "a0 = def a.\n__END__\n; end rescue b0"...'',
+      "def a.b(c=\n__END__\n); end"...'',
+      "<<x.\n 1111\nx\na0 rescue b0()\n"...'',
+      'a rescue BEGIN{b}'...'',
+      'a rescue a=*b rescue c'...'',
+      'a rescue a rescue a=1,2 rescue 4'...'',
+      'a rescue a0 = b 1 do end rescue c'...'',
+      'a0 = ~bend'...'',
+      'a,((BEGIN {})).w,c=d,e,f'...'',
+      'a,(* =f,g rescue b and c).w,c=d,e,f'...'',
+      'a,(a0 rescue b0=b,d rescue c).w=d'...'',
+      'a[*b]=a=b,c=d'...'',
+      'class<<a; begin; r; t end;c end'...'',
+      'def a0unde;  undef new, ne; end'...'',
+      'def a0.a & b; end'...'',
+      'def a0.a  b=c do end; hhh end'...'',
+      'def a0.a b=c,d=e do f end; end'...'',
+      'def a0.a b=c,d=e e2 do f end; end'...'',
+      'def a0.a b=c,d=e e2 e3 do f end; end'...'',
+      'def a0.a b=c,d=e e2 e3 e4 do f end; end'...'',
+      'def a0.a b=c,d=e() do f end; end'...'',
+      'def a0.a( b=c,d=e do f end ); end'...'',
+      'def a0.a( b=c,d=e() do f end ); end'...'',
+      'def a0.a*b; end'...'',
+      'def a0.a* b; end'...'',
+      'def a0.a * b; end'...'',
+      'def a0.a&b; end'...'',
+      'def a0.a& b; end'...'',
+      'def a0.a & b; end'...'',
+      'begin undef a,b;rr end'...'',
+      '"foo#{"dfg#{"sdfsd"}" }"; sdfasd'...'',
     ]
 
 
@@ -2929,9 +3132,17 @@ class RedParseTest<Test::Unit::TestCase
        \\"
      foo
 
+def a1(a2=  %s[\
+]);end
 END
 
   STANZAS=PASSTHRU_BSLASHES_ENTIRE+%q[
+  "#{p "#{<<-kekerz}#{"foob"
+     zimpler
+     kekerz
+     }"
+  }"
+
   @@anon = Module.new
   class @@anon::I
     bindtextd 
@@ -3415,8 +3626,7 @@ end
     assert(!$bad)
     s = "a string"
     s[0..s.size]="another string"
-    assert_equal("another string", s)
-    s = <<EOS
+    assert_equal("another string",    s = <<EOS
 #{
 [1,2,3].join(",")
 }
@@ -3660,6 +3870,92 @@ end
 <<-EOS<<__LINE__
 EOS
 
+def (
+__END__
+).foo; end
+
+def (a=
+__END__
+).foo; end
+
+-0.0
+__END__
+**31
+
+p (M.
+__END__
+)
+
+module
+__END__
+::Foo; end
+
+a,(%
+__END__
+[a]).w,c=d,e,f
+
+alias :"
+__END__
+#{bar}" :"baz#{quux}"
+
+undef :"
+__END__
+#{bar}"
+
+p Module.
+__END__
+
+p (
+__END__
+)
+
+def (  def test_endblockwarn
+    ruby = EnvUtil.rubybin
+    # Use Tempfile to create temporary file path.
+    launcher = Tempfile.new(self.class.name)
+    errout = Tempfile.new(self.class.name)
+    launcher << <<EOF
+errout = ARGV.shift
+STDERR.reopen(File.open(errout, "w"))
+STDERR.sync = true
+Dir.chdir(#{q(DIR)})
+cmd = "\\"#{ruby}\\" \\"endblockwarn.rb\\""
+system(cmd)
+EOF
+    launcher.close
+    launcherpath = launcher.path
+    errout.close
+    erroutpath = errout.path
+    system("#{q(ruby)} #{q(launcherpath)} #{q(erroutpath)}")
+    expected = <<EOW
+endblockwarn.rb:2: warning: END in method; use at_exit
+(eval):2: warning: END in method; use at_exit
+EOW
+    assert_equal(expected, File.read(erroutpath))
+    # expecting Tempfile to unlink launcher and errout file.
+  end).foo; end
+
+def (  def test_endblockwarn
+<<EOF
+irqDIR
+cmd
+EOF
+<<EOW
+endblat_exit
+EOW
+  end).foo; end
+
+def (
+<<EOF
+irqDIR
+cmd
+EOF
+<<EOW
+endblat_exit
+EOW
+).foo; end
+
+
   ] ##############################END OF STANZAS#################################################
   ###############################################################################################
 
@@ -3725,6 +4021,8 @@ EOS
     'a rescue (...)',
     "((...))",
     'def ((...)).foo; end',
+    'def a0.(...); end',
+    'def a0.a1(a2=(...)); end',
     'a0 = (...) rescue b0',
     'a0 = ((...)) rescue b0',    
     '(...)  #with a comment',
@@ -3736,12 +4034,40 @@ EOS
     "b=1;b (...)",
     "return (...)",
     '"#{(...)}"',
+    '"#{*(...)}"',
+    '*(...)',
+    '*(...)=y',
+    'a,*((...)).w=d,e,f',
+    'a,((...)).w,c=d,e,f',
+    '[(...),1,2,3]',
+    '{(...)=>x}',
+    '{x=>(...)}',
+    'm((...))',
+    'm (...)',
   ]
   INJECTABLES=[  #take it easy with these too
     'p (1..10).method(:each)',
     'a0 rescue b0',
     'begin; r; t end',
     'a=b,c=d',
+    "\n__END__\n",
+    '* =f,g',
+    '
+     <<-foo
+       xxx
+     foo
+     <<-bar
+       yyy
+     bar
+    ',
+    '
+     <<-foo
+       xxx
+     foo
+    ',
+   'm;n',
+   'undef rth, hty',
+   'alias rth hty',
   ]
   if ENV['MANGLE']
   else
@@ -3750,9 +4076,16 @@ EOS
     puts "warning: most data fuzzing is disabled; set MANGLE to enable"
   end
 
-  RUBYIDENT=/((?:$|@@?)?#{RubyLexer::LETTER}#{RubyLexer::LETTER_DIGIT}*[?!]?)/o
+  RUBYIDENT=/((?:\$|@@?)?#{RubyLexer::LETTER}#{RubyLexer::LETTER_DIGIT}*[?!]?)/o
+
+  SEEN_SNIPPETS={}
 
   def self.snippet2testmethod(snippet,wrap=nil)
+    if SEEN_SNIPPETS[snippet]
+      return
+    else
+      SEEN_SNIPPETS[snippet]=1
+    end
     escaped=snippet.gsub(/[\\']/){"\\"+$&}
     safe=escaped.gsub(/([^ -~])/){
       x=$1[0]
@@ -3764,7 +4097,7 @@ EOS
     safe.gsub! /\\\\/,"__"
     safe[/[^ -~]|\\\\/] and fail
     cp="check_parsing '#{escaped}'"
-    cp="#{wrap}{#{cp}}" if wrap
+    cp="#{wrap}('#{escaped}'){|x| check_parsing x}" if wrap
     "
       define_method 'test_parsing_of_#{safe}' do
         #puts 'test_parsing_of_#{safe}'
@@ -3836,27 +4169,31 @@ EOS
 
   Test::Unit::AssertionFailedError=MiniTest::Assertion unless defined? Test::Unit::AssertionFailedError
 
-  def known_ruby_bug
+  def known_ruby_bug x
     from=caller.first
     from=from[/ in `.*'\Z/] || from[/\A[^:]*:[^:]*/]
-    yield
+    yield x
   rescue Test::Unit::AssertionFailedError=>e
-    warn "a known bug in MRI reared its head in #{from}: #{e.message}"
+    warn "a known bug in ParseTree/MRI reared its head in #{from}: '#{x unless /\n./===x or x.size>65}'"
     if defined? @@known_ruby_bugs
-      @@known_ruby_bugs+=1
+      @@known_ruby_bugs<<x
     else
-      @@known_ruby_bugs=1
-      at_exit {warn "unfixed bugs in MRI/ParseTree: #@@known_ruby_bugs"}
+      warn e.message
+      @@known_ruby_bugs=[x]
+      extra_summary {
+        warn "unfixed bugs in ParseTree/MRI: #{@@known_ruby_bugs.size}"
+        @@known_ruby_bugs.each{|bug| warn "  "+bug unless bug["\n"] }
+      }
     end
   rescue Exception=>e
     raise
   else
-    warn "expected bug in MRI in #{from}, but was fixed(?!)"
+    warn "expected bug in ParseTree/MRI in #{from}, but was fixed(?!)"
     if defined? @@known_ruby_bugs_fixed
       @@known_ruby_bugs_fixed+=1
     else
       @@known_ruby_bugs_fixed=1
-      at_exit {warn "unexpectedly fixed known MRI/ParseTree bugs: #@@known_ruby_bugs_fixed"}
+      extra_summary {warn "unexpectedly fixed known ParseTree/MRI bugs: #@@known_ruby_bugs_fixed"}
     end
   end
 
@@ -3936,7 +4273,6 @@ EOS
         foo
       "=>[[:str, "        \\\\\\\\\\\\'\n"]],
 
-
     }.each_pair{|code,tree| 
       assert_equal tree,RedParse.new(code,'-',1,[],:cache_mode=>:none).parse.to_parsetree(:quirks)
     }
@@ -3959,7 +4295,7 @@ EOS
         @@missed_syntax_errors+=1
       else
         @@missed_syntax_errors=1
-        at_exit{warn "missed syntax errors: #@@missed_syntax_errors"}
+        extra_summary{warn "missed syntax errors: #@@missed_syntax_errors"}
       end
       #puts "warning: syntax error expected, but none was seen, expression: <<< #{xmpl} >>>" if 
       #  POWERS_OF_2[@@missed_syntax_errors]
@@ -3979,6 +4315,7 @@ EOS
 
   def ParseTree.server_running_187?
     #@server_running_187||=nil
+    return nil if !defined? @out
     return @server_running_187 unless @server_running_187.nil?
     put :version
     version=get
@@ -3992,41 +4329,25 @@ EOS
     return @server_running_187= version=="1.8.7"
   end
 
+
+
+  @@differed_by_begin=0
   def check_parsing xmpl
-    ParseTree.fork_server?
+    xmpl.force_encoding "binary"
     xmpl=xmpl.dup.freeze
     pt_opts=[:quirks]
     pt_opts<<:ruby187 if ParseTree.server_running_187?
     /unparse/===xmpl and warn 'unparse in parser test data!'
     problem_exprs=problem_exprs()
     nodes=warnings=warnings2=nil
-=begin
-      xmpl=<<-prefix+xmpl+<<-suffix
-        BEGIN{throw :never_exec_parse_data_try1,1}
-        BEGIN{throw :never_exec_parse_data_try2,2}
-        BEGIN{throw :never_exec_parse_data_try3,3}
-        BEGIN{raise "never_exec_parse_data_try4"}
-        BEGIN{raise "never_exec_parse_data_try5"}
-      prefix
-        ;0
-      suffix
-=end
-#        tree=nil
-#        output=false
-#        loops=0
-      begin
-#        output=
-#        catch(:never_exec_parse_data_try1){
-#          catch(:never_exec_parse_data_try2){
-#            catch(:never_exec_parse_data_try3){
-              tree,warnings=ParseTree.parse_tree_and_warnings(xmpl)
-#            }
-#          }
-#        }
-#        break if loops+=1 > 3
-      rescue Interrupt; raise
-      rescue Exception=>e
-        tree=e
+    if tree=$pt_known_output[xmpl]
+      tree=tree.dup
+      warnings=tree.pop[:warnings] if Array===tree and Hash===tree.last        #+[__,+{warnings:String}]
+    else
+      tree,warnings=ParseTree.parse_tree_and_warnings(xmpl)
+      PTLOG.record_pt_output(xmpl,tree,warnings) if ENV['PTLOG']
+    end
+      if Exception===tree
         tree2=nodes=h=nil
         assert_hopefully_raises_Exception(xmpl){
           nodes=RedParse.new(xmpl,"-",1,[],:cache_mode=>:write_only).parse
@@ -4044,8 +4365,14 @@ EOS
             assert true
           else
             assert_equal tree, RedParse.remove_silly_begins(tree2)
-            warn "parse_trees differed by a :begin in #{xmpl}"
             differed_by_begin=true
+            if @@differed_by_begin==0 or ENV['DIFFER_BY_BEGIN']
+              warn "parse_trees differed by a :begin in #{xmpl}"
+              extra_summary{warn "differed by begin: #@@differed_by_begin"} unless ENV['DIFFER_BY_BEGIN']
+            elsif @@differed_by_begin==1
+              warn "more parse_trees differ by a :begin (set DIFFER_BY_BEGIN for details)"
+            end
+            @@differed_by_begin+=1
           end
           assert_equal warnings, warnings2 if ENV['WARN_PICKINESS']
           if warnings != warnings2
@@ -4053,7 +4380,7 @@ EOS
               @@mismatched_warnings+=1
             else
               @@mismatched_warnings=1
-              at_exit{warn "mismatched warnings: #@@mismatched_warnings (set WARN_PICKINESS for details)"}
+              extra_summary{warn "mismatched warnings: #@@mismatched_warnings (set WARN_PICKINESS for details)"}
             end
           end
         rescue Interrupt; raise
@@ -4063,11 +4390,6 @@ EOS
             problem_exprs.flush
           end
           raise e
-        else
-          if false and problem_exprs and tree!=tree2
-            problem_exprs.write xmpl+"\n"
-            problem_exprs.flush
-          end
         end #rescue false
         
       end #until output.equal? tree 
@@ -4078,7 +4400,7 @@ EOS
         assert_equal nodes,nodes2
 
         begin
-          unparsed=nodes.unparse
+          unparsed=nodes.unparse :exact=>true, :linenum=>1
           if unparsed==xmpl
             assert true
             done_already=true
@@ -4095,7 +4417,7 @@ EOS
                 @@unparse_mismatched_linenums+=1
             else
                 @@unparse_mismatched_linenums=1
-                at_exit{warn "unparse mismatched linenums: #@@unparse_mismatched_linenums"}
+                extra_summary{warn "unparse mismatched linenums: #@@unparse_mismatched_linenums"}
             end
           else
             assert true 
@@ -4105,7 +4427,7 @@ EOS
         end unless done_already
 
         assert_equal nodes, Marshal.load(Marshal.dump(nodes))
-        assert_equal nodes, Ron.load(Ron.dump(nodes)) if defined? Ron
+        #assert_equal nodes, Ron.load(Ron.dump(nodes)) if defined? Ron
         assert_equal nodes, nodes.deep_copy
 
         unless done_already or Exception===tree or differed_by_begin