livetext 0.9.10 → 0.9.15

data/test/snapshots.rb

@@ -0,0 +1,169 @@
+require 'minitest/autorun'
+
+require_relative '../lib/livetext'
+
+=begin
+Snapshots...
+
+NOTE that the external_files method has been replaced by the Snapshot class.
+
+You can add any ordinary test method above. But so far, most of these tests simply 
+call Snapshot.new
+
+It works this way: 
+  - If the test (caller) method is test_my_silly_feature, then we will
+    look for a directory called snapshots/my_silly_feature
+  - In here, there must be a source.lt3
+  - ...and also either expected-output.txt OR match-output.txt (not both)
+  - ...and also either expected-error.txt OR match-error.txt (not both)
+  - Technically, any existing file can be empty
+  - The expected-* files are "literal" data
+      * compared byte-for-byte
+      * watch spaces and bad regexes, etc. #duh
+      * each of these files corresponds to a single assertion 
+  - A match-* file has two entries per line: 
+      * a ONE-BASED line number (in actual-* file)
+      * a String OR a Regexp (to match against that line)
+      * If there is nonsense here, it currently isn't caught
+      * each of these files MAY correspond to many assertions 
+  - We run livetext on the source and compare actual vs expected (stdout, stderr)
+  - The error output gets checked first (expected or match), THEN standard output
+  - Of course, both must compare correctly for the test to pass
+=end
+
+
+# Just a testing class. Chill.
+
+class TestingLivetext < MiniTest::Test
+
+  class Snapshot
+    SOURCE = "source.lt3"
+    # Will now keep "actual" output in same dir?
+    ACTUAL_OUT, ACTUAL_ERR = "actual-output.txt", "actual-error.txt"
+    EXP_OUT,    EXP_ERR    = "expected-output.txt", "expected-error.txt"
+    MATCH_OUT,  MATCH_ERR  =  "match-output.txt", "match-error.txt"
+
+    def initialize(base, assertion = nil)
+      @assertion = assertion
+      @base = base
+      @errors = false
+      Dir.chdir(base) do
+        @literal_out = File.exist?(EXP_OUT)
+        @literal_err = File.exist?(EXP_ERR)
+        @match_out = File.exist?(MATCH_OUT)
+        @match_err = File.exist?(MATCH_ERR)
+      end
+      bad_files = (@literal_out && @match_out) || (@literal_err && @match_err) ||
+                  (! @literal_out && ! @match_out)
+      raise "Inconsistent structure for #@base" if bad_files
+    end
+
+    def check_matches(actual, control)
+      controls = File.readlines(control).map(&:chomp)
+      lines = File.readlines(actual).map(&:chomp)
+      lines.unshift("DUMMY LINE")   # 1-based index! (for when I'm editing)
+      controls.each do |line|
+        line_num, item = line.split(" ", 2)
+        item = Regexp.new(item[1..-2]) if item[0] == "/"  # Hmm, string can't start with /...
+        line_num = line_num.to_i
+        info = "Expected line #{line_num} of #{actual.inspect} to match #{item.inspect} (was: #{lines[line_num].inspect})"
+        good = item === lines[line_num]
+        @errors = true unless good
+        @assertion.call item === lines[line_num], info   # string or regex
+      end
+    end
+
+    def sdiff(f1, f2, out)
+      File.open(out, "w") {|file| file.puts "#{'%-60s'% 'ACTUAL'}| #{'%-60s'% 'EXPECTED'}" }
+      system("/usr/bin/sdiff -t -w 121 #{f1} #{f2} >>#{out}")
+    end
+
+    def check_stdout
+      if @literal_out
+        actual, expected = File.read(ACTUAL_OUT), File.read(EXP_OUT)
+        same = actual == expected
+        @errors = true if not same
+        file = "out-sdiff.txt"
+        sdiff(ACTUAL_OUT, EXP_OUT, file)
+        @assertion.call same, "Discrepancy in STDOUT - see #{file} in test/snapshots/#@base"
+      else
+        check_matches(ACTUAL_OUT, MATCH_OUT)
+      end
+    end
+
+    def check_stderr
+      if @literal_err
+        actual, expected = File.read(ACTUAL_ERR), File.read(EXP_ERR)
+        same = actual == expected
+        @errors = true if not same
+        file = "err-sdiff.txt"
+        sdiff(ACTUAL_ERR, EXP_ERR, file)
+        @assertion.call same, "Discrepancy in STDERR - see #{file} in test/snapshots/#@base"
+      else
+        check_matches(ACTUAL_ERR, MATCH_ERR)
+      end
+    end
+
+    def cleanup
+      return if @errors
+      system("rm -f #{ACTUAL_OUT} #{ACTUAL_ERR} *sdiff.txt")
+    end
+
+    def filter  # TODO move subset/omit logic here??
+    end
+
+    def run
+      @errors = false   # oops, need to reset
+      Dir.chdir(@base) do
+        cmd = "../../../bin/livetext #{SOURCE} >#{ACTUAL_OUT} 2>#{ACTUAL_ERR}"
+        system(cmd)
+        check_stderr
+        check_stdout
+        cleanup
+      end
+    end
+  end
+
+  TTY = File.open("/dev/tty","w")
+
+  cmdline = ARGV.first == "cmdline"   # FIXME remove??
+  if cmdline
+    dir = "../"
+    Dir.chdir `livetext --path`.chomp.chomp
+  else
+    dir = ""
+  end
+
+  Data = "#{dir}test/snapshots"
+  Dir.chdir(Data)
+
+  TestDirs = Dir.entries(".").reject {|fname| ! File.directory?(fname) } - %w[. ..]
+
+  selected = File.readlines("subset.txt").map(&:chomp)
+
+  omitfile = "OMIT.txt"
+  omitted  = File.readlines(omitfile).map(&:chomp)
+  omitted.reject! {|line| line.start_with?("#") }
+  omit_names = omitted.map {|line| line.split.first }
+  STDERR.puts
+  STDERR.puts "  >>> Warning: Omitting #{omitted.size} snapshot tests:\n " 
+  indented = " "*7
+  omitted.each do |line| 
+    STDERR.print indented 
+    name, info = line.split(" ", 2)
+    STDERR.printf "%-20s  %s\n", name, info
+  end
+  STDERR.puts
+
+  wanted   = selected.empty? ? TestDirs : selected
+
+  Subset = wanted - omit_names
+
+  Subset.each do |tdir|
+    define_method("test_#{tdir}") do
+      myproc = Proc.new {|bool, info| assert bool, info }
+      this = Snapshot.new(tdir, myproc)
+      this.run
+    end
+  end
+end

data/test/testlines.rb

@@ -1,5 +1,5 @@
-require 'livetext'
-require 'formatline'
+require '../lib/livetext'
+require '../lib/formatline'
 
   def red(str)
     "" + str + ""
@@ -8,20 +8,30 @@ require 'formatline'
 input = ARGV.first || "test/data/lines.txt"
 data = File.readlines(input)
 
-data.each_slice(4) do |lines|
+pass = fail = 0
+data.each_slice(4).with_index do |lines, i|
   title, input, expected, blank = *lines
+  lnum = i*4 + 1
   input.chomp!
   expected.chomp!
   expected = eval(expected) if expected[0] == "/"
   
-  puts "-----------------------------"
-  print "Test:      #{title}"
 
   actual = FormatLine.parse!(input)
-  next if expected === actual
+  if expected === actual
+    pass += 1
+#   puts "PASS:      #{title}"
+    next
+  end
 
-  puts "Input:     #{input}"
+  fail += 1
+  puts "----------------------------- (line #{lnum})"
+  puts "Test:  #{title}"
+  puts "Input: #{input}"
   puts "  #{red('FAIL Expected: ')} #{expected.inspect}"
   puts "  #{red('     Actual  : ')} #{actual.inspect}"
   puts 
 end
+
+puts
+puts "#{pass} passes   #{fail} fails"

data/test/unit/all.rb

@@ -0,0 +1,4 @@
+
+require_relative 'standard'
+require_relative 'parser'      # nested
+require_relative 'formatline'