git.oblomov.eu Git - ohcount/blob - test/test_helper.rb

   1 require 'test/unit'
   2 require 'fileutils'
   3 require 'find'
   4
   5 TEST_DIR = File.dirname(__FILE__)
   6 require TEST_DIR + '/../lib/ohcount'
   7
   8 class LingoTest < Test::Unit::TestCase
   9
  10         # For reasons unknown, the base class defines a default_test method to throw a failure.
  11         # We override it with a no-op to prevent this 'helpful' feature.
  12         def default_test
  13         end
  14
  15         def src_dir
  16                 TEST_DIR + "/src_dir"
  17         end
  18
  19         def scratch_dir
  20                 TEST_DIR + "/scratch_dir"
  21         end
  22
  23         def expected_dir
  24                 TEST_DIR + "/expected_dir"
  25         end
  26
  27         def verify_parse(src_filename, filenames = [])
  28                 # re-make the output directory
  29                 Dir.mkdir scratch_dir unless File.exists? scratch_dir
  30                 output_dir = scratch_dir + "/#{ File.basename(src_filename) }"
  31                 FileUtils.rm_r(output_dir) if FileTest.directory?(output_dir)
  32                 Dir.mkdir output_dir
  33
  34                 complete_src_filename = src_dir + "/#{ src_filename }"
  35     sfc = Ohcount::SimpleFileContext.new(complete_src_filename, filenames)
  36                 polyglot = Ohcount::Detector.detect(sfc)
  37
  38                 # parse
  39                 buffer = File.new(complete_src_filename).read
  40                 Ohcount::Parser.parse_to_dir(:dir => output_dir,
  41                                                                                                                                 :buffer => buffer,
  42                                                                                                                                 :polyglot => polyglot)
  43
  44                 # now compare
  45                 answer_dir = expected_dir + "/#{ File.basename(src_filename) }"
  46                 compare_dir(answer_dir, output_dir)
  47
  48                 # just to be sure, lets compare the total number of lines from the source file and the processed breakdown
  49                 compare_line_count(complete_src_filename, output_dir)
  50         end
  51
  52
  53         def compare_dir(expected, actual)
  54                 # make sure entries are identical
  55                 expected_entries = expected.entries.collect { |e| e[expected.size..-1] }
  56                 actual_entries = actual.entries.collect { |a| a[actual.size..-1] }
  57                 assert_equal expected_entries, actual_entries
  58
  59                 Dir.foreach(expected) do |entry|
  60                         next if [".", "..", ".svn"].include?(entry)
  61                         case File.ftype(expected+ "/" + entry)
  62                         when 'file'
  63                                 File.open(expected + "/" + entry) do |e|
  64                                         File.open(actual + "/" + entry) do |a|
  65                                                 assert_equal e.read, a.read, "file #{actual + "/" + entry} differs from expected"
  66                                         end
  67                                 end
  68                         when 'directory'
  69                                 compare_dir(expected + "/" + entry, actual + "/" + entry)
  70                         else
  71                                 assert false, "weird ftype"
  72                         end
  73                 end
  74         end
  75
  76
  77         def compare_line_count(src_file, scratch_dir)
  78                 code_lines = comment_lines = blanks = 0
  79
  80                 Find.find(scratch_dir) do |path|
  81                         if FileTest.file?(path)
  82                                 `wc -l #{ path }` =~ /^\s*(\d*)\b/
  83                                 case File.basename(path)
  84                                 when 'code'
  85                                         code_lines += $1.to_i
  86                                 when 'comment'
  87                                         comment_lines += $1.to_i
  88                                 when 'blanks'
  89                                         blanks += File.new(path).read.to_i
  90                                 end
  91                         end
  92                 end
  93
  94                 # src file lines
  95                 `wc -l #{ src_file }` =~ /^\s*(\d*)\b/
  96                 src_file_lines = $1.to_i
  97
  98                 # compare
  99                 assert_equal src_file_lines, (code_lines + comment_lines + blanks), "wc -l of output (code, comment, blanks) doesn't match the 'wc -l' of original"
 100         end
 101 end
 102