gravitext-util 1.4.0-java

data/History.rdoc

@@ -0,0 +1,36 @@
+=== 1.4.0 (2010-5-8)
+* New generic UniMap (Java) with ruby dynamic accessor extension.
+* New Charsets constants.
+* New Streams utilities; ByteBufferInputStream and ByteArrayInputStream.
+* New ResizableByteBufferOutputStream.
+* New Closeables utilities.
+* ArrayHTMap and HashHTMap are no longer final (supports UniMap).
+* Added immutable public KeySpace.keys().
+* Added convenience methods KeySpace.createGeneric() and createListKey().
+* Added URL64 encoder/decoder utility.
+* Added explicit dev dependencies for rjack-slf4j and rjack-logback.
+* Remove old/deprecated perftest.* harness and ConcurrentTest*
+* Use rjack-tarpit for build.
+* Set gem platform to java.
+
+=== 1.3.2 (2009-8-6)
+* Add ConstrainedInputStream.readLength() and mark/reset support.
+
+=== 1.3.1 (2009-8-2)
+* ResizableByteBuffer.putFromStream break on zero length read.
+* Add ConstrainedInputStream.
+* Use rdoc 2.4.3 and hoe 1.12.2 for build.
+
+=== 1.3 (2009-2-23)
+* New gem packaging.
+* Replaced java perftest harness with ruby test harness/wiring.
+* Split heterogeneous access methods from HTMap to HTAccess interface
+  to enable generic filters and other consumers.
+* Non-checked exception version of Closeable interface.
+
+=== 1.2 (2008-4-28)
+* Added ResizableByteBuffer, ResizableCharBuffer,
+  ResizableCharBufferWriter classes.
+
+=== 1.1 (2007-7-15)
+* First public release.

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.rdoc
+Manifest.txt
+NOTICE.txt
+README.rdoc
+Rakefile
+pom.xml
+bin/gravitext-perftest
+lib/gravitext-util/version.rb
+lib/gravitext-util.rb
+lib/gravitext-util/concurrent.rb
+lib/gravitext-util/perftest.rb
+lib/gravitext-util/unimap.rb
+test/test_concurrent.rb
+test/test_perftest.rb
+test/test_unimap.rb
+lib/gravitext-util/gravitext-util-1.4.0.jar

data/NOTICE.txt

@@ -0,0 +1,2 @@
+gravitext-util
+Copyright (c) 2007-2010 David Kellum

data/README.rdoc

@@ -0,0 +1,45 @@
+= gravitext-util
+
+* http://gravitext.rubyforge.org
+* http://gravitext.com/oss/gravitext-util
+* http://github.com/dekellum/gravitext
+
+== Description
+
+A collection of core java utilities with ruby adapters for JRuby.
+
+* A concurrent (thread safety) testing facility for java JUnit,
+  ruby Test::Unit, or other test harnesses.
+
+* A concurrent performance testing facility for java/JRuby with simple
+  test wiring in ruby.
+
+* A Heterogeneous Type-safe Map implementation in java with
+  dynamically generated ruby accessors.
+
+* A set of core java utility classes (resizable buffers, a stopwatch,
+  SI unit formatting, fast random number generator), in support of the
+  above and of general utility.
+
+== Dependencies
+
+* Java 1.5+
+* JRuby 1.1.6+
+* rjack-slf4j[http://rjack.rubyforge.org/slf4j] and
+  rjack-logback[http://rjack.rubyforge.org/logback] gems for testing.
+
+== License
+
+Copyright (c) 2007-2010 David Kellum
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License.  You
+may obtain a copy of the License at:
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied.  See the License for the specific language governing
+permissions and limitations under the License.

data/Rakefile

@@ -0,0 +1,37 @@
+# -*- ruby -*-
+
+$LOAD_PATH << './lib'
+require 'gravitext-util/version'
+
+require 'rubygems'
+gem     'rjack-tarpit', '~> 1.2.0'
+require 'rjack-tarpit'
+
+t = RJack::TarPit.new( 'gravitext-util',
+                       Gravitext::Util::VERSION,
+                       :no_assembly, :java_platform )
+
+t.specify do |h|
+  h.developer( "David Kellum", "dek-oss@gravitext.com" )
+  h.extra_dev_deps += [ [ 'rjack-slf4j',   '~> 1.5.8'  ],
+                        [ 'rjack-logback', '>= 0.9.17' ] ]
+  h.rubyforge_name = "gravitext"
+end
+
+file 'Manifest.txt' => [ 'lib/gravitext-util/version.rb' ]
+
+task :check_pom_version do
+  t.test_line_match( 'pom.xml', /<version>/, /#{t.version}/ )
+end
+task :check_history_version do
+  t.test_line_match( 'History.rdoc', /^==/, / #{t.version} / )
+end
+task :check_history_date do
+  t.test_line_match( 'History.rdoc', /^==/, /\([0-9\-]+\)$/ )
+end
+
+task :gem  => [ :check_pom_version, :check_history_version                      ]
+task :tag  => [ :check_pom_version, :check_history_version, :check_history_date ]
+task :push => [                                             :check_history_date ]
+
+t.define_tasks

data/bin/gravitext-perftest

@@ -0,0 +1,128 @@
+#!/usr/bin/env jruby
+# -*- ruby -*-
+#--
+# Copyright (c) 2007-2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+$LOAD_PATH.unshift File.join( File.dirname(__FILE__), "..", "lib" )
+
+require 'gravitext-util'
+require 'gravitext-util/perftest'
+require 'java'
+
+module TestCollection
+  include Gravitext
+  include Gravitext::Concurrent
+
+  import 'com.gravitext.htmap.perftests.HTMapPerfTest'
+  import 'com.gravitext.perftest.tests.EmptyPerfTest'
+  import 'com.gravitext.perftest.tests.SortPerfTest'
+  import 'com.gravitext.util.perftests.ByteBufferInputStreamPerfTest'
+  import 'com.gravitext.util.perftests.FastRandomPerfTest'
+  import 'com.gravitext.util.perftests.ResizableCharBufferWriterPerfTest'
+
+  def self.run
+    tests = TestCollection::lookup_factories( ARGV[0] || 'random' )
+
+    harness = PerfTest::Harness.new( tests )
+    # harness.do_per_run_timing = false #FIXME
+    # harness.thread_count = 2
+    # harness.final_runs = 10000
+
+    harness.execute
+  end
+
+  def self.lookup_factories( name )
+    case name
+    when 'random'
+      tests = FastRandomPerfTest::Mode.values.map do |mode|
+        FastRandomPerfTest.new( mode )
+      end
+
+      btest = BlockTestFactory.new do |run,fr|
+        10_000.times do
+          rand( 1000 )
+        end
+        rand( 3 )
+      end
+      btest.name = 'Ruby-Kernel.rand'
+      tests << btest
+
+      btest = BlockTestFactory.new do |run,random|
+        10_000.times do
+          random.next_int( 1000 )
+        end
+        random.next_int( 3 )
+      end
+      btest.name = 'Ruby-FAST'
+      tests << btest
+
+      tests
+    when 'htmap'
+      HTMapPerfTest::TEST_CLASSES.map do |cls|
+        HTMapPerfTest.new( cls )
+      end
+    when 'buffer-writer'
+      ResizableCharBufferWriterPerfTest::TEST_CLASSES.map do |cls|
+        ResizableCharBufferWriterPerfTest.new( cls )
+      end
+    when 'buffer-instream'
+      tests = ByteBufferInputStreamPerfTest::TEST_CLASSES.map do |cls|
+        ByteBufferInputStreamPerfTest.new( cls )
+      end
+      tests += ByteBufferInputStreamPerfTest::TEST_CLASSES.map do |cls|
+        t = ByteBufferInputStreamPerfTest.new( cls )
+        t.read_one = true
+        t
+      end
+    when 'empty'
+      btest = BlockTestFactory.new { 1 }
+      btest.name = 'RubyEmptyBlock'
+      [ EmptyPerfTest.new, REmptyTestFactory.new, btest ]
+    when 'sort'
+      btest = BlockTestFactory.new do
+        numbers = []
+        ( rand( 10000 ) + 10 ).times do
+          numbers << rand( 10000 )
+        end
+        numbers.sort!
+        numbers.first
+      end
+      btest.name = 'RubySort'
+      [ SortPerfTest.new, btest ]
+    end
+  end
+
+  class REmptyTestFactory
+    include Gravitext::Concurrent
+    include TestFactory
+    include TestRunnable
+
+    def name
+      'RubyEmpty'
+    end
+
+    def create_test_runnable( seed )
+      self.class.new
+    end
+
+    def run_iteration( run )
+      1
+    end
+  end
+
+end
+
+TestCollection.run

data/lib/gravitext-util.rb

@@ -0,0 +1,29 @@
+#--
+# Copyright (c) 2007-2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'gravitext-util/version'
+require 'java'
+
+module Gravitext
+  module Util
+    require File.join( LIB_DIR, "gravitext-util-#{ VERSION }.jar" )
+
+    import 'com.gravitext.util.FastRandom'
+  end
+
+  require 'gravitext-util/concurrent'
+  require 'gravitext-util/unimap'
+end

data/lib/gravitext-util/concurrent.rb

@@ -0,0 +1,110 @@
+#--
+# Copyright (c) 2007-2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'java'
+require 'gravitext-util'
+
+module Gravitext
+
+  # Provides a concurrent testing facility
+  module Concurrent
+    import 'com.gravitext.concurrent.TestExecutor'
+    import 'com.gravitext.concurrent.TestFactory'
+    import 'com.gravitext.concurrent.TestRunnable'
+
+    # Returns the number of available processor cores on the host.
+    def self.available_cores
+      Java::java.lang.Runtime::runtime.available_processors
+    end
+
+    # Run TestRunnable instances created from (TestFactory)
+    # test_factory concurrently with threads (one TestRunnable
+    # per thread.).  The first of any Exceptions raised in a test
+    # thread will be re-raised in the calling thread. Returns sum of
+    # runIteration return counts.
+    def self.execute_test_factory( test_factory, runs,
+                                   threads = available_cores )
+      TestExecutor::run( test_factory, runs, threads )
+    end
+
+    # Run test_runnable_class instances concurrently in threads. The
+    # test_runnable_class should take a instance of FastRandom in its
+    # initialize(). The first of any Exceptions raised in a test
+    # thread will be re-raised in the calling thread. Returns sum of
+    # runIteration return counts.
+    def self.execute_runnable( test_runnable_class, runs,
+                               threads = available_cores )
+      TestExecutor::run( BasicTestFactory.new( test_runnable_class ),
+                         runs, threads )
+    end
+
+    # Run block concurrently in the specified number of threads. The
+    # first of any Exceptions raised in block will be re-raised in the
+    # calling thread. Returns sum of runIteration return counts.
+    #
+    # :call-seq:
+    #   execute_test(runs,threads = available_cores) { |run,random| ... } -> Integer
+    def self.execute_test( runs, threads = available_cores, &block )
+      TestExecutor::run( BlockTestFactory.new( block ), runs, threads )
+    end
+
+    class BlockTestFactory
+      include TestFactory
+
+      attr_accessor :name
+
+      def initialize( proc = nil, &block )
+        @name = 'BlockTestFactory'
+        @block = proc || block
+      end
+
+      def create_test_runnable( seed )
+        BlockTestRunnable.new( seed, @block )
+      end
+    end
+
+    class BlockTestRunnable
+      include TestRunnable
+
+      def initialize( seed, block )
+        @block = block
+        @random = Gravitext::Util::FastRandom.new( seed )
+      end
+
+      def run_iteration( run )
+        @block.call( run, @random )
+      end
+    end
+
+    class BasicTestFactory
+      include TestFactory
+
+      def initialize( test_class )
+        @test_class = test_class
+      end
+
+      def name
+        @test_class.name
+      end
+
+      def create_test_runnable( seed )
+        @test_class.new( Gravitext::Util::FastRandom.new( seed ) )
+      end
+    end
+
+  end
+
+end

data/lib/gravitext-util/perftest.rb

@@ -0,0 +1,408 @@
+#--
+# Copyright (c) 2007-2010 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'gravitext-util'
+
+require 'ostruct'
+require 'java'
+
+module Gravitext
+
+  # Concurrent performance testing facility
+  module PerfTest
+
+    module CalcUtil #:nodoc: all
+
+      NaN = Java::java.lang.Double::NaN
+
+      def throughput_change( exec, prior = nil )
+        if prior
+          p = prior.mean_throughput
+          ( exec.mean_throughput - p ) / p
+        else
+          NaN
+        end
+      end
+
+      def latency_change( exec, prior = nil )
+        if prior
+          p = prior.mean_latency.seconds
+          ( exec.mean_latency.seconds - p ) / p
+        else
+          NaN
+        end
+      end
+    end
+
+    # Concurrent performance testing harness with support for adaptive
+    # warmup and comparison on multiple TestFactory instances.
+    class Harness
+      include CalcUtil
+      import 'com.gravitext.concurrent.TestExecutor'
+      import 'com.gravitext.util.Duration'
+
+      # Number of threads to test with (default: available cores)
+      attr_accessor :thread_count
+
+      # Target duration of warmup comparison iterations in seconds (default:8s)
+      attr_accessor :warmup_exec_target
+
+      # Minimum warmup time in seconds for each test factory (default: 25s)
+      attr_accessor :warmup_total_target
+
+      # Secondary warmup requirement: consectutive iteration
+      # throughputs within tollerance (default: 0.05)
+      attr_accessor :warmup_tolerance
+
+      # Number of final comparison iterations (default: 3)
+      attr_accessor :final_iterations
+
+      # Number of runs in final comparisons (default: computed from
+      # warmup and final_exec_target)
+      attr_accessor :final_runs
+
+      # Target duration of final comparison iterations in seconds (default: 10s)
+      attr_accessor :final_exec_target
+
+      # Test executation progress is sent to listener, see PrintListener.
+      attr_accessor :listener
+
+      # Do per run timing for mean latency. (default: true)
+      attr_accessor :do_per_run_timing
+
+      # Maximum difference in counts for final run counts to be
+      # alligned (default: 3.0)
+      attr_accessor :max_align_ratio
+
+      # Initialize given array of com.gravitext.concurrent.TestFactory
+      # instances.
+      def initialize( factories )
+        @factories = factories
+        @thread_count = Concurrent::available_cores
+
+        @warmup_exec_target = 8.0
+        @warmup_total_target = 25
+        @warmup_tolerance = 0.05
+
+        @final_iterations = 3
+        @final_runs = nil
+        @final_exec_target = 10.0
+
+        @max_align_ratio = 3.0
+        @do_per_run_timing = true
+
+        @listener = PrintListener.new
+      end
+
+      def execute
+        @listener.begin( self, @factories )
+
+        finals = warmup
+
+        run_counts = if @final_runs
+                       Array.new( @factories.size, @final_runs )
+                     else
+                       counts = @factories.map do |factory|
+                         exec = finals.detect { |e| e.factory == factory }
+                         ( exec.mean_throughput * @final_exec_target ).to_i
+                       end
+                       align_counts( counts )
+                     end
+
+        results = execute_comparisons( run_counts, @final_iterations )
+        sums = sum_results( results ) if @final_iterations > 1
+
+        @listener.comparisons_end( self, sums )
+        sums
+      end
+
+      def warmup
+
+        @listener.warmups_begin( self )
+
+        states = @factories.map do |factory|
+          s = OpenStruct.new
+          s.factory = factory
+          s.prior = nil
+          s.warm_time = 0.0
+          s
+        end
+
+        first = true
+        finals = []
+        until states.empty? do
+
+          @listener.warmup_next_series( self ) unless first
+
+          states,done = states.partition do |s|
+
+            # Cleanup before each run
+            Java::java.lang.System::gc
+            Java::java.lang.Thread::yield
+
+            runs = if s.prior
+                     ( @warmup_exec_target * s.prior.runs_executed ) /
+                       s.prior.duration.seconds
+                   else
+                     1
+                   end
+
+            executor = create_executor( s.factory, runs.to_i )
+            @listener.warmup_start_run( executor )
+            executor.run_test
+            @listener.warmup_complete_run( executor, s.prior )
+
+            # Test throughput change, and increment warm_time
+            s.warm_time += executor.duration.seconds
+            tchange = throughput_change( executor, s.prior )
+            s.prior = executor
+
+            ( ( s.warm_time < @warmup_total_target ) ||
+              ( tchange.abs > @warmup_tolerance ) )
+          end
+          finals += done.map { |s| s.prior }
+          first = false
+        end
+
+        @listener.warmups_end( finals )
+        finals
+      end
+
+      def align_counts( counts )
+        mean = ( counts.inject { |sum,c| sum + c } ) / counts.size
+
+        # Round to 2-significant digits
+        f = 1
+        ( f *= 10 ) while ( mean / f ) > 100
+        mean = ( mean.to_f / f ).round * f
+
+        if ( mean.to_f / counts.min ) > @max_align_ratio
+          counts
+        else
+          Array.new( counts.size, mean )
+        end
+      end
+
+      def execute_comparisons( run_counts, iterations )
+
+        results = Array.new( @factories.size ) { [] }
+
+        @listener.comparisons_begin( self, run_counts )
+
+        iterations.times do |iteration|
+          @listener.comparison_next_series( self ) unless iteration.zero?
+
+          Java::java.lang.System::gc
+          Java::java.lang.Thread::yield
+
+          @factories.each_index do |f|
+            executor = create_executor( @factories[f], run_counts[f] )
+            @listener.comparison_start_run( executor )
+            executor.run_test
+            @listener.comparison_complete_run( executor, results[0].last )
+            results[f] << executor
+          end
+        end
+
+        results
+      end
+
+      def sum_results( results )
+        sums = []
+
+        results.each do |runs|
+          sum = OpenStruct.new
+          sum.factory            = runs.first.factory
+          sum.runs_target        = 0
+          sum.duration           = 0.0
+          sum.result_sum         = 0
+          sum.runs_executed      = 0
+          sum.mean_throughput    = 0.0
+          sum.mean_latency       = 0.0
+
+          runs.each do |exec|
+            sum.runs_target     += exec.runs_target
+            sum.duration        += exec.duration.seconds
+            sum.result_sum      += exec.result_sum
+            sum.runs_executed   += exec.runs_executed
+            sum.mean_throughput += exec.mean_throughput
+            sum.mean_latency    += exec.mean_latency.seconds
+          end
+
+          sum.duration           = Duration.new( sum.duration )
+          sum.mean_throughput   /= runs.size
+          sum.mean_latency       = Duration.new( sum.mean_latency / runs.size )
+
+          sums << sum
+        end
+
+        sums
+      end
+
+      def create_executor( factory, runs )
+        executor = TestExecutor.new( factory, runs, @thread_count )
+        executor.do_per_run_timing = @do_per_run_timing
+        executor
+      end
+
+    end
+
+    # Listen for various events from the Harness and print results to console
+    class PrintListener
+      include CalcUtil
+      import 'com.gravitext.util.Metric'
+
+      # Status is written via out << (default $stdout)
+      def initialize( out = $stdout )
+        @out = out
+      end
+
+      def begin( harness, factories )
+        @out << "Concurrent testing: #{harness.thread_count} threads."
+        new_line
+        @nwidth = ( factories.map { |f| f.name.length } << 4 ).max
+      end
+
+      def warmups_begin( harness )
+        @out << ( "Warmup min %gs (change tolerance: %g) per test:" %
+                  [ harness.warmup_total_target, harness.warmup_tolerance ] )
+        new_line
+        print_header
+      end
+
+      def warmup_start_run( executor )
+        print_result_start( executor )
+      end
+
+      def warmup_complete_run( executor, prior )
+        print_result( executor, prior )
+      end
+
+      def warmup_next_series( harness )
+        print_separator
+      end
+
+      def warmups_end( final_executors )
+        new_line
+      end
+
+      def comparisons_begin( harness, run_counts )
+        @out << ( "Comparison runs (%d iterations):" %
+                  [ harness.final_iterations ] )
+        new_line
+        print_header
+      end
+
+      def comparison_next_series( harness )
+        print_separator
+      end
+
+      def comparison_start_run( executor )
+        print_result_start( executor )
+      end
+
+      def comparison_complete_run( executor, prior )
+        print_result( executor, prior )
+      end
+
+      def comparisons_end( harness, executor_sums )
+        print_separator( '=' )
+        executor_sums.each_index do |s|
+          print_result_start( executor_sums[s] )
+          print_result( executor_sums[s], ( executor_sums.first unless s.zero? ) )
+        end
+      end
+
+      def new_line
+        @out << "\n"
+      end
+
+      def print_header
+        @out << ( "%-#{@nwidth}s %-6s %-7s %-6s %8s %10s(%6s) %-9s (%6s)" %
+                  [ "Test",
+                    "Count",
+                    "Time",
+                    "R Sum",
+                    "~R Value",
+                    "Throughput",
+                    "Change",
+                    "~Latency",
+                    "Change" ] )
+        new_line
+        print_separator( '=' )
+      end
+
+      def print_separator( char = '-' )
+        @out << ( char * ( @nwidth + 69 ) )
+        new_line
+      end
+
+      def print_result_start( exec, out = @out )
+        out << ( "%-#{@nwidth}s %6s " %
+                 [ exec.factory.name,
+                   Metric::format( exec.runs_target ) ] )
+      end
+
+      def print_result( exec, prior = nil, out = @out )
+        out << ( "%7s %6s %6s/r %6sr/s (%6s) %7s/r (%6s)" %
+                 [ exec.duration,
+                   Metric::format( exec.result_sum.to_f ),
+                   Metric::format( exec.result_sum.to_f /
+                                   exec.runs_executed ),
+                   Metric::format( exec.mean_throughput ),
+                   Metric::format_difference( throughput_change(exec,prior) ),
+                   exec.mean_latency,
+                   Metric::format_difference( latency_change(exec,prior) ) ] )
+        new_line
+      end
+
+    end
+
+    # Derivation of PrintListener for consise debug log output
+    class LogListener < PrintListener
+
+      # Send <<() to log.debug
+      class LogWriter
+        def initialize( log )
+          @log = log
+        end
+        def <<( msg )
+          @log.debug( msg )
+        end
+      end
+
+      def initialize( logger )
+        super( LogWriter.new( logger ) )
+      end
+
+      alias :orig_result_start :print_result_start
+      def print_result_start( exec ); end
+
+      # Print run start and result output on single log line
+      def print_result( exec, prior = nil )
+        line = ""
+        orig_result_start( exec, line )
+        super( exec, prior, line )
+        @out << line
+      end
+
+      def new_line; end
+      def print_separator( char = '-' ); end
+
+    end
+
+  end
+end