seeing_is_believing 2.2.0 → 3.0.0.beta.1

data/lib/seeing_is_believing/event_stream/update_result.rb

@@ -0,0 +1,21 @@
+require 'seeing_is_believing/event_stream/events'
+class SeeingIsBelieving
+  module EventStream
+    module UpdateResult
+      def self.call(result, event)
+         case event
+         when EventStream::Events::LineResult       then result.record_result(event.type, event.line_number, event.inspected)
+         when EventStream::Events::UnrecordedResult then result.record_result(event.type, event.line_number, '...') # <-- is this really what I want?
+         when EventStream::Events::Exception        then result.record_exception event.line_number, event.class_name, event.message, event.backtrace
+         when EventStream::Events::Stdout           then result.stdout             = event.value
+         when EventStream::Events::Stderr           then result.stderr             = event.value
+         when EventStream::Events::BugInSiB         then result.bug_in_sib         = event.value
+         when EventStream::Events::MaxLineCaptures  then result.number_of_captures = event.value
+         when EventStream::Events::Exitstatus       then result.exitstatus         = event.value
+         when EventStream::Events::NumLines         then result.num_lines          = event.value
+         else raise "Unknown event: #{event.inspect}"
+         end
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/inspect_expressions.rb

@@ -0,0 +1,24 @@
+require 'seeing_is_believing/wrap_expressions'
+class SeeingIsBelieving
+  module InspectExpressions
+    def self.call(program, number_of_captures, options={})
+      number_of_captures_as_str = number_of_captures.inspect
+      number_of_captures_as_str = 'Float::INFINITY' if number_of_captures == Float::INFINITY
+
+      wrap_expressions_callbacks = {}
+      wrap_expressions_callbacks[:before_all]  = options.fetch :before_all,  -> { "begin; $SiB.max_line_captures = #{number_of_captures_as_str}; $SiB.num_lines = #{program.lines.count}; " }
+      wrap_expressions_callbacks[:after_all]   = options.fetch :after_all,   -> { ";rescue Exception;"\
+                                                                                     "lambda {"\
+                                                                                       "line_number = $!.backtrace.grep(/\#{__FILE__}/).first[/:\\d+/][1..-1].to_i;"\
+                                                                                       "$SiB.record_exception line_number, $!;"\
+                                                                                       "$SiB.exitstatus = 1;"\
+                                                                                       "$SiB.exitstatus = $!.status if $!.kind_of? SystemExit;"\
+                                                                                     "}.call;"\
+                                                                                   "end"
+                                                                              }
+      wrap_expressions_callbacks[:before_each] = options.fetch :before_each, -> line_number { "(" }
+      wrap_expressions_callbacks[:after_each]  = options.fetch :after_each,  -> line_number { ").tap { |v| $SiB.record_result(:inspect, #{line_number}, v) }" }
+      WrapExpressions.call program, wrap_expressions_callbacks
+    end
+  end
+end

data/lib/seeing_is_believing/parser_helpers.rb

@@ -1,14 +1,4 @@
-module Parser
-  class << self
-    # With new versioning, there's lots of small versions
-    # we don't need it to complain that we're on 2.1.1 and its parsing 2.1.5
-    # https://github.com/whitequark/parser/blob/e2249d7051b1adb6979139928e14a81bc62f566e/lib/parser/current.rb#L3
-    def warn(*) end
-    require 'parser/current'
-    remove_method :warn
-  end
-end
-
+require 'parser/current'
 class SeeingIsBelieving
   module ParserHelpers
 

data/lib/seeing_is_believing/result.rb

@@ -1,44 +1,11 @@
-require 'seeing_is_believing/line'
-require 'seeing_is_believing/has_exception'
-
 class SeeingIsBelieving
   class Result
-    include HasException
     include Enumerable
+    RecordedException = Struct.new :line_number, :class_name, :message, :backtrace
 
-    def self.from_primitive(primitive)
-      new.from_primitive(primitive)
-    end
-
-    def from_primitive(primitive)
-      self.exitstatus = primitive['exitstatus']
-      self.stdout     = primitive['stdout']
-      self.stderr     = primitive['stderr']
-      self.bug_in_sib = primitive['bug_in_sib']
-      self.exception  = RecordedException.from_primitive primitive['exception']
-      primitive['results'].each do |line_number, primitive_line|
-        results_for(line_number.to_i).from_primitive(primitive_line)
-      end
-      self
-    end
-
-    def to_primitive
-      primitive = {
-        'exitstatus' => exitstatus,
-        'stdout'     => stdout,
-        'stderr'     => stderr,
-        'bug_in_sib' => bug_in_sib,
-        'exception'  => (exception && exception.to_primitive),
-      }
-      primitive['results'] = results.each_with_object({}) do |(line_number, line), r|
-        r[line_number] = line.to_primitive
-      end
-      primitive
-    end
-
-
-    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib, :number_of_captures
+    attr_accessor :stdout, :stderr, :exitstatus, :bug_in_sib, :number_of_captures, :exception, :num_lines
 
+    alias has_exception? exception
     alias bug_in_sib? bug_in_sib
 
     def has_stdout?
@@ -49,32 +16,22 @@ class SeeingIsBelieving
       stderr && !stderr.empty?
     end
 
-    def record_result(line_number, value)
-      results_for(line_number).record_result(value)
+    def record_result(type, line_number, value)
+      results_for(line_number, type) << value
       value
     end
 
-    def record_exception(line_number, exception)
-      recorded_exception = RecordedException.new exception.class.name,
-                                                 exception.message,
-                                                 exception.backtrace
-      self.exception = recorded_exception
-      results_for(line_number).exception = recorded_exception
+    def record_exception(line_number, exception_class, exception_message, exception_backtrace)
+      self.exception = RecordedException.new line_number, exception_class, exception_message, exception_backtrace
     end
 
-    def [](line_number)
-      results_for(line_number)
+    def [](line_number, type=:inspect)
+      results_for(line_number, type)
     end
 
     def each(&block)
-      max = results.keys.max || 1
-      (1..max).each { |line_number| block.call self[line_number] }
-    end
-
-    def each_with_line_number(&block)
-      return to_enum :each_with_line_number unless block
-      max = results.keys.max || 1
-      (1..max).each { |line_number| block.call line_number, results_for(line_number) }
+      return to_enum :each unless block
+      (1..num_lines).each { |line_number| block.call self[line_number] }
     end
 
     def inspect
@@ -97,8 +54,9 @@ class SeeingIsBelieving
 
     private
 
-    def results_for(line_number)
-      results[line_number] ||= Line.new([], number_of_captures)
+    def results_for(line_number, type)
+      line_results = (results[line_number] ||= Hash.new { |h, k| h[k] = [] })
+      line_results[type]
     end
 
     def results

data/lib/seeing_is_believing/the_matrix.rb

@@ -5,30 +5,30 @@
 #
 # (or if you want to understand why we do the pipe dance)
 
+require_relative 'version'
+require_relative 'event_stream/producer'
 
-require 'json'
-require 'seeing_is_believing/result'
-$SiB = SeeingIsBelieving::Result.new
+stdout_real_obj = STDOUT      # the real Ruby object, fake file descriptor
+stdout_real_fd  = STDOUT.dup  # duped Ruby object,    real file descriptor
+read_from_mock_out, write_to_mock_out = IO.pipe
+stdout_real_obj.reopen write_to_mock_out
 
-stdout_real_obj = STDOUT      # the real Ruby object, but its FD is going to keep getting reopened
 stderr_real_obj = STDERR
-stdout_real_fd  = STDOUT.dup  # duped Ruby object, but with the real file descriptor
 stderr_real_fd  = STDERR.dup
-
-read_from_mock_out, write_to_mock_out = IO.pipe
 read_from_mock_err, write_to_mock_err = IO.pipe
-
-stdout_real_obj.reopen write_to_mock_out
 stderr_real_obj.reopen write_to_mock_err
 
+$SiB = SeeingIsBelieving::EventStream::Producer.new(stdout_real_fd)
+
 at_exit do
   stdout_real_obj.reopen stdout_real_fd
-  stderr_real_obj.reopen stderr_real_fd
   write_to_mock_out.close unless write_to_mock_out.closed?
-  write_to_mock_err.close unless write_to_mock_err.closed?
-  $SiB.stdout = read_from_mock_out.read
-  $SiB.stderr = read_from_mock_err.read
+  $SiB.record_stdout read_from_mock_out.read
   read_from_mock_out.close
+
+  stderr_real_obj.reopen stderr_real_fd
+  write_to_mock_err.close unless write_to_mock_err.closed?
+  $SiB.record_stderr read_from_mock_err.read
   read_from_mock_err.close
 
   $SiB.exitstatus ||= 0
@@ -36,5 +36,5 @@ at_exit do
   $SiB.exitstatus   = $!.status if $!.kind_of? SystemExit
   $SiB.bug_in_sib   = $! && ! $!.kind_of?(SystemExit)
 
-  stdout_real_fd.write JSON.dump $SiB.to_primitive
+  $SiB.finish!
 end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '2.2.0'
+  VERSION = '3.0.0.beta.1'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -1,3 +1,4 @@
+require 'parser/current'
 require 'seeing_is_believing/parser_helpers'
 
 # comprehensive list of syntaxes that can come up
@@ -13,8 +14,8 @@ class SeeingIsBelieving
 
     def initialize(program, wrappings)
       self.program     = program
-      self.before_all  = wrappings.fetch :before_all,  ''.freeze
-      self.after_all   = wrappings.fetch :after_all,   ''.freeze
+      self.before_all  = wrappings.fetch :before_all,  -> { ''.freeze }
+      self.after_all   = wrappings.fetch :after_all,   -> { ''.freeze }
       self.before_each = wrappings.fetch :before_each, -> * { '' }
       self.after_each  = wrappings.fetch :after_each,  -> * { '' }
       self.buffer, parser, self.rewriter = initialize_parser(program, 'program-without-annotations')
@@ -28,10 +29,9 @@ class SeeingIsBelieving
       @called ||= begin
         find_wrappings
 
-        if root # file may be empty
-          rewriter.insert_before root.location.expression, before_all
-
+        rewriter.insert_before root_range, before_all.call
 
+        if root # file may be empty
           wrappings.each do |line_num, (range, last_col, meta)|
             rewriter.insert_before range, before_each.call(line_num)
             if meta == :total_fucking_failure
@@ -39,11 +39,10 @@ class SeeingIsBelieving
             end
             rewriter.insert_after  range, after_each.call(line_num)
           end
-
           range = root.location.expression
-          rewriter.insert_after range, after_all
         end
 
+        rewriter.insert_after root_range, after_all_text
         rewriter.process
       end
     end
@@ -52,6 +51,26 @@ class SeeingIsBelieving
 
     attr_accessor :program, :before_all, :after_all, :before_each, :after_each, :buffer, :root, :rewriter, :wrappings
 
+    def root_range
+      if root
+        root.location.expression
+      else
+        Parser::Source::Range.new buffer, 0, 0
+      end
+    end
+
+    def after_all_text
+      after_all_text         = after_all.call
+      data_segment_code      = "__END__\n"
+      code_after_end_of_file = buffer.source[root_range.end_pos, data_segment_code.size]
+      ends_in_data_segment   = code_after_end_of_file.chomp == data_segment_code.chomp
+      if ends_in_data_segment
+        "#{after_all_text}\n"
+      else
+        after_all_text
+      end
+    end
+
     def add_to_wrappings(range_or_ast, meta=nil)
       range = range_or_ast
       range = range_or_ast.location.expression if range.kind_of? ::AST::Node
@@ -71,7 +90,11 @@ class SeeingIsBelieving
       case ast.type
       when :args, :redo, :retry, :alias, :undef, :splat, :match_current_line
         # no op
-      when :rescue, :ensure, :def, :return, :break, :next
+      when :defs
+        add_to_wrappings ast
+        child = ast.children.last
+        add_to_wrappings child if child
+      when :rescue, :ensure, :return, :break, :next
         add_children ast
       when :if
         if ast.location.kind_of? Parser::Source::Map::Ternary
@@ -84,7 +107,7 @@ class SeeingIsBelieving
           end
           add_children ast
         end
-      when :when, :pair, :defs, :class, :module, :sclass
+      when :when, :pair, :class, :module, :sclass
         find_wrappings ast.children.last
       when :resbody
         exception_type, variable_name, body = ast.children

data/seeing_is_believing.gemspec

@@ -19,15 +19,15 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             "parser",   ">= 2.2", "< 3.0"
-  s.add_dependency             "psych",    "~> 2.0"
+  s.add_dependency             "eval_in",  "~> 0.1.6"
+  s.add_dependency             "parser",   ">= 2.1.4",  "< 2.3"
 
-  s.add_development_dependency "pry",      "~> 0.10.0"
-  s.add_development_dependency "haiti",    "~> 0.1.0"
+  s.add_development_dependency "webmock",  "~>  1.18"
+  s.add_development_dependency "haiti",    ">= 0.1",    "< 0.3"
   s.add_development_dependency "rake",     "~> 10.0"
-  s.add_development_dependency "rspec",    "~> 3.0"
-  s.add_development_dependency "cucumber", "~> 1.2"
-  s.add_development_dependency "ichannel", "~> 5.1"
+  s.add_development_dependency "rspec",    "~>  3.0"
+  s.add_development_dependency "cucumber", "~>  1.2"
+  s.add_development_dependency "ichannel", "~>  5.1"
 
   s.post_install_message = <<'Omg, frogs <3'.gsub(/(gg+)/) { |capture| "\e[32m#{capture.gsub 'g', '.'}\e[0m" }.gsub("brown", "\e[33m").gsub("off", "\e[0m")
               .7

data/spec/binary/comment_formatter_spec.rb

@@ -1,44 +1,49 @@
+# encoding: utf-8
+
 require 'spec_helper'
 require 'seeing_is_believing/binary/comment_formatter'
 
-describe SeeingIsBelieving::Binary::CommentFormatter do
-  def result_for(line, separator, result, options={})
-    described_class.new(line, separator, result, options).call
+RSpec.describe SeeingIsBelieving::Binary::CommentFormatter do
+  def result_for(line_length, separator, result, options={})
+    described_class.new(line_length, separator, result, options).call
   end
 
   specify 'it returns the consolidated result if there are no truncations' do
     expect(result_for 1, '=>', '12345').to eq '=>12345'
   end
 
-  specify 'result_length truncates a result to the specified length, using elipses up to that length if appropriate'  do
+  specify 'max_result_length truncates a result to the specified length, using elipses up to that length if appropriate'  do
     line_length = 1
     separator   = '=>'
     result      = '12345'
-    expect(result_for line_length, separator, result, max_result_length: Float::INFINITY).to eq '=>12345'
-    expect(result_for line_length, separator, result, max_result_length: 7              ).to eq '=>12345'
-    expect(result_for line_length, separator, result, max_result_length: 6              ).to eq '=>1...'
-    expect(result_for line_length, separator, result, max_result_length: 5              ).to eq '=>...'
-    expect(result_for line_length, separator, result, max_result_length: 4              ).to eq ''
-    expect(result_for line_length, separator, result, max_result_length: 0              ).to eq ''
+    expect(result_for line_length,   separator, result, max_result_length: Float::INFINITY).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_result_length: 7              ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_result_length: 6              ).to eq '=>1...'
+    expect(result_for line_length+1, separator, result, max_result_length: 6              ).to eq '=>1...'
+    expect(result_for line_length,   separator, result, max_result_length: 5              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_result_length: 4              ).to eq ''
+    expect(result_for line_length,   separator, result, max_result_length: 0              ).to eq ''
   end
 
-  specify 'line_length truncates a result to the specified length, minus the length of the line' do
+  specify 'max_line_length truncates a result to the specified length, minus the length of the line' do
     line_length = 1
     separator   = '=>'
     result      = '12345'
-    expect(result_for line_length, separator, result                                  ).to eq '=>12345'
-    expect(result_for line_length, separator, result, max_line_length: Float::INFINITY).to eq '=>12345'
-    expect(result_for line_length, separator, result, max_line_length: 8              ).to eq '=>12345'
-    expect(result_for line_length, separator, result, max_line_length: 7              ).to eq '=>1...'
-    expect(result_for line_length, separator, result, max_line_length: 6              ).to eq '=>...'
-    expect(result_for line_length, separator, result, max_line_length: 5              ).to eq ''
-    expect(result_for line_length, separator, result, max_line_length: 0              ).to eq ''
+    expect(result_for line_length,   separator, result                                  ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: Float::INFINITY).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: 8              ).to eq '=>12345'
+    expect(result_for line_length,   separator, result, max_line_length: 7              ).to eq '=>1...'
+    expect(result_for line_length+1, separator, result, max_line_length: 7              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_line_length: 6              ).to eq '=>...'
+    expect(result_for line_length,   separator, result, max_line_length: 5              ).to eq ''
+    expect(result_for line_length,   separator, result, max_line_length: 0              ).to eq ''
   end
 
   specify 'pad_to will pad the length that the line is displayed in' do
     expect(result_for 1, '=>', '2', pad_to: 0).to eq '=>2'
     expect(result_for 1, '=>', '2', pad_to: 1).to eq '=>2'
     expect(result_for 1, '=>', '2', pad_to: 2).to eq ' =>2'
+    expect(result_for 2, '=>', '2', pad_to: 2).to eq '=>2'
   end
 
   specify 'pad_to is ignored when separator/result will not be printed' do
@@ -52,4 +57,150 @@ describe SeeingIsBelieving::Binary::CommentFormatter do
     expect(result_for 1, '=>', '12345', max_line_length: 100, max_result_length:   6, pad_to: 2).to eq ' =>1...'
     expect(result_for 1, '=>', '12345', max_line_length: 100, max_result_length:   6, pad_to: 2).to eq ' =>1...'
   end
+
+  def assert_printed(c, printed)
+    c = c.force_encoding 'utf-8'
+    expect(result_for 0, '', c).to eq printed
+  end
+
+  it 'escapes any non-printable characters' do
+    assert_printed     '©' , '©'
+    assert_printed   0.chr , "\\u0000"
+    assert_printed   1.chr , "\\u0001"
+    assert_printed   2.chr , "\\u0002"
+    assert_printed   3.chr , "\\u0003"
+    assert_printed   4.chr , "\\u0004"
+    assert_printed   5.chr , "\\u0005"
+    assert_printed   6.chr , "\\u0006"
+    assert_printed   7.chr , "\\a"
+    assert_printed   8.chr , "\\b"
+    assert_printed   9.chr , "\\t"
+    assert_printed  10.chr , "\\n"
+    assert_printed  11.chr , "\\v"
+    assert_printed  12.chr , "\\f"
+    assert_printed  13.chr , "\\r"
+    assert_printed  14.chr , "\\u000E"
+    assert_printed  15.chr , "\\u000F"
+    assert_printed  16.chr , "\\u0010"
+    assert_printed  17.chr , "\\u0011"
+    assert_printed  18.chr , "\\u0012"
+    assert_printed  19.chr , "\\u0013"
+    assert_printed  20.chr , "\\u0014"
+    assert_printed  21.chr , "\\u0015"
+    assert_printed  22.chr , "\\u0016"
+    assert_printed  23.chr , "\\u0017"
+    assert_printed  24.chr , "\\u0018"
+    assert_printed  25.chr , "\\u0019"
+    assert_printed  26.chr , "\\u001A"
+    assert_printed  27.chr , "\\e"
+    assert_printed  28.chr , "\\u001C"
+    assert_printed  29.chr , "\\u001D"
+    assert_printed  30.chr , "\\u001E"
+    assert_printed  31.chr , "\\u001F"
+    assert_printed  32.chr , " "
+    assert_printed  33.chr , "!"
+    assert_printed  34.chr , '"' # printable, thus not escaped
+    assert_printed  35.chr , "#"
+    assert_printed  36.chr , "$"
+    assert_printed  37.chr , "%"
+    assert_printed  38.chr , "&"
+    assert_printed  39.chr , "'"
+    assert_printed  40.chr , "("
+    assert_printed  41.chr , ")"
+    assert_printed  42.chr , "*"
+    assert_printed  43.chr , "+"
+    assert_printed  44.chr , ","
+    assert_printed  45.chr , "-"
+    assert_printed  46.chr , "."
+    assert_printed  47.chr , "/"
+    assert_printed  48.chr , "0"
+    assert_printed  49.chr , "1"
+    assert_printed  50.chr , "2"
+    assert_printed  51.chr , "3"
+    assert_printed  52.chr , "4"
+    assert_printed  53.chr , "5"
+    assert_printed  54.chr , "6"
+    assert_printed  55.chr , "7"
+    assert_printed  56.chr , "8"
+    assert_printed  57.chr , "9"
+    assert_printed  58.chr , ":"
+    assert_printed  59.chr , ";"
+    assert_printed  60.chr , "<"
+    assert_printed  61.chr , "="
+    assert_printed  62.chr , ">"
+    assert_printed  63.chr , "?"
+    assert_printed  64.chr , "@"
+    assert_printed  65.chr , "A"
+    assert_printed  66.chr , "B"
+    assert_printed  67.chr , "C"
+    assert_printed  68.chr , "D"
+    assert_printed  69.chr , "E"
+    assert_printed  70.chr , "F"
+    assert_printed  71.chr , "G"
+    assert_printed  72.chr , "H"
+    assert_printed  73.chr , "I"
+    assert_printed  74.chr , "J"
+    assert_printed  75.chr , "K"
+    assert_printed  76.chr , "L"
+    assert_printed  77.chr , "M"
+    assert_printed  78.chr , "N"
+    assert_printed  79.chr , "O"
+    assert_printed  80.chr , "P"
+    assert_printed  81.chr , "Q"
+    assert_printed  82.chr , "R"
+    assert_printed  83.chr , "S"
+    assert_printed  84.chr , "T"
+    assert_printed  85.chr , "U"
+    assert_printed  86.chr , "V"
+    assert_printed  87.chr , "W"
+    assert_printed  88.chr , "X"
+    assert_printed  89.chr , "Y"
+    assert_printed  90.chr , "Z"
+    assert_printed  91.chr , "["
+    assert_printed  92.chr , "\\" # printable, thus not escaped
+    assert_printed  93.chr , "]"
+    assert_printed  94.chr , "^"
+    assert_printed  95.chr , "_"
+    assert_printed  96.chr , "`"
+    assert_printed  97.chr , "a"
+    assert_printed  98.chr , "b"
+    assert_printed  99.chr , "c"
+    assert_printed 100.chr , "d"
+    assert_printed 101.chr , "e"
+    assert_printed 102.chr , "f"
+    assert_printed 103.chr , "g"
+    assert_printed 104.chr , "h"
+    assert_printed 105.chr , "i"
+    assert_printed 106.chr , "j"
+    assert_printed 107.chr , "k"
+    assert_printed 108.chr , "l"
+    assert_printed 109.chr , "m"
+    assert_printed 110.chr , "n"
+    assert_printed 111.chr , "o"
+    assert_printed 112.chr , "p"
+    assert_printed 113.chr , "q"
+    assert_printed 114.chr , "r"
+    assert_printed 115.chr , "s"
+    assert_printed 116.chr , "t"
+    assert_printed 117.chr , "u"
+    assert_printed 118.chr , "v"
+    assert_printed 119.chr , "w"
+    assert_printed 120.chr , "x"
+    assert_printed 121.chr , "y"
+    assert_printed 122.chr , "z"
+    assert_printed 123.chr , "{"
+    assert_printed 124.chr , "|"
+    assert_printed 125.chr , "}"
+    assert_printed 126.chr , "~"
+  end
+
+  it 'can be given a list of characters to not escape' do
+    expect(result_for 0, '', "\r\n", dont_escape: ["\n"]).to eq "\\r\n"
+    expect(result_for 0, '', "\r\n", dont_escape: ["\r"]).to eq "\r\\n"
+  end
+
+  it 'escapes them before running through the other calculations' do
+    expect(result_for 1, '=>', "\r\n", max_line_length: 7).to eq '=>\r\n'
+    expect(result_for 1, '=>', "\r\n", max_line_length: 6).to eq '=>...'
+  end
 end