more_unit_test 0.1.2 → 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzcyN2QwZTc2M2VjNzljMWZmMDgwMGRhYmIyMTZiYWZhOGEzOTlkMQ==
+  data.tar.gz: !binary |-
+    NjQ5YjQ1ZWRjNWEzZjZjZTFmY2UxYzFmYjllZjg5ZjgzNzljYTJiNA==
+SHA512:
+  metadata.gz: !binary |-
+    ZDI4MWZhZjkzMTQyZThjNGFiMTFiM2Q5NWYxNmE0ZGVlYmEwOWMzNzhiN2Ez
+    ZTVhZDNjYzQwMmY2OGY4NzY1ZTFmOTljZTlhMzA0MzE3NjVjMGMyMDE1ZTYy
+    ODg1Y2JiZWJmNDI2Njk3NTQ0Y2YyNTU1MTNmYjExYmI0YmY5ODM=
+  data.tar.gz: !binary |-
+    NDUwOTdmYjkyODlhMTg3ZWI3NjgyZjFkMzJhMzcwODBmMjI5MmM2ZTNmNjFh
+    ODBlZDE4MWU0ZmU5YjRhNmJmMzdjYWViNGZmNDA5ZDNkYzVkYWIxYWIyNjk2
+    OGRlMDgzNWI2OTUxNzA5ZmQ4NmY4ZTQzMjYzOTM5ZGQ5YTFmMzA=

data/lib/more_unit_test.rb

@@ -10,4 +10,8 @@ Compare expected result with file content
 ===more_unit_test/assert_stdout.rb
 Test for stdout/stderr
 
-=end
+=end
+
+module More_Unit_Test
+  VERSION = '0.2.0'
+end  

data/lib/more_unit_test/assert_equal_filecontent.rb

@@ -14,21 +14,17 @@ Here it is: Test::Unit::TestCase#assert_equal_filecontent
 See http://rubyforge.org/tracker/?func=detail&aid=19509&group_id=5650&atid=21859
 
 ==Ruby 1.9
-With ruby 1.9 you get an additional encoding problem.
-The "expected"-file is read with a default encoding, 
-your test result may differ.
+Ruby 1.9 supports encoding information for strings.
+The "expected"-file is read with the encoding of your result.
 
-You can set the default encoding for reading files with 
-  Encoding.default_external 
-
-Or you define a read option for the test:
+You may overwrite this with:
   class MyTest < Test::Unit::TestCase
     def test_utf()
-      self.readoption = 'r:utf-8'
+      self.read_encoding = 'utf-8'
       assert_equal_filecontent( "expected/test_utf.txt", mycall() )
     end
   end
-
+.
 =end
 require 'test/unit'
 #~ puts RUBY_VERSION
@@ -37,22 +33,33 @@ require 'fileutils'
 require 'date'  #needed for Ruby 1.9 (class Date no standard?)
 
 =begin rdoc
-Extend the class TestCase with additional methods/assertions
+Extend the class TestCase with additional methods/assertions:
+
+* Test::Unit::TestCase#assert_equal_filecontent
 =end
 class Test::Unit::TestCase
-  #define option to read "expected"-file. may define conversions.
-  attr_writer :readoption
+  #Default path in case of an error.
+  FOLDER_FOR_FAILURE = "failure_#{Date.today}"
+  #Default path in case of an error. Overwrites FOLDER_FOR_FAILURE.
+  #With 'false' no file is written
+  attr_writer :folder_for_failure
+  #Overwrite encoding of 'expected' file.
+  #Needed for each test method.
+  attr_writer :read_encoding
 
 =begin rdoc
 Takes the content of the file 'filename' and compares it with 'actual' like in assert_equal.
-If 'filname' doesn't exist, the failure 
+If 'filename' doesn't exist, the failure 
  Reference file <#{filename}> missing
 is returned.
 
 'folder_for_failure' will contain all results with differences.
 
 Example of the usage:
-    assert_equal_filecontent( "expected/test_section.html", text.to_doc(:html))
+    assert_equal_filecontent( "expected/test_section.html", 
+                              text.to_doc(:html), 
+                              'short description of test'
+                            )
 
 What will happen:
 1. text.to_doc(:html) is the test. It creates some HTML-Text
@@ -61,58 +68,158 @@ What will happen:
    2. If it is the same -> fine 
    3. If there are differences:
 3. A message is given (like in assert_equal)
-4. A folder "failure#{Date.today}" is created if not already exist
-5. The file 'test_section.html' with the result is created in "failure#{Date.today}/"
-6. I can use a compare tool to compare the expected result and the real result.
-
-Recommendation to build up your test.
-1. Create two folders: 'expected' and 'failure'
-2. Define your assertion with a non-existing filename
-3. Run the test with folder_for_failure = 'failure'
-4. You will get a failure (filename is missing).
-5. Copy the file in 'failure' to 'expected'
+4. A folder "failure_#{Date.today}" is created if not already exist (See FOLDER_FOR_FAILURE )
+5. The file 'test_section.html' with the result is created in FOLDER_FOR_FAILURE
+6. You can use a compare tool to compare the expected result and the real result.
+
+If you don't want a failure file (step 4 and 5), you may suppress it with:
+  def text_no_failure file
+    self.folder_for_failure = false  #inactivate error/reference file creation.
+    #...
+  end
+
+==filename
+The filename may contains some parameters in <x>. 
+Details see Test::Unit::TestCase#build_filename
+
+==Recommendation to build up your test.
+1. Define your tests with your assertions.
+2. Run the test 
+3. You will get errors 'Reference file <xx/not_available.txt> missing'
+  and a directory 'failure_<date>
+4. Rename the folder 'failure' to 'expected'
+5. Check, if the content of the folder is the wanted result.
 6. Rerun again, you have no failure (hopefully ;-) )
+
+If you already have the result, you may start like this:
+1. Create a folder: 'expected'
+2. Define your assertion with non-existing filename in the 'expected'-folder.
+3. Copy the expected results to the 'expected'-folder.
+4. Run the test
+5. In case of errors:
+Compare the content of the 'expected'-folder with the failure-folder.
+Adapt your code or your expected result.
+6. Rerun again, until you get the expected results
 =end
-  def assert_equal_filecontent( filename, actual, folder_for_failure = "failure#{Date.today}", message = nil )
+  def assert_equal_filecontent( filename, actual, message = nil )
     #
-    @readoption = 'r' unless @readoption
+    filename = build_filename(filename)
+      #Set encoding, if actual includes encoding-info.
+    encoding = Encoding.default_external 
+    encoding = actual.encoding if actual.respond_to?(:encoding)
+    encoding = @read_encoding if @read_encoding #encoding was overwritten
+    
     #Make the tests
     if File.exist?(filename)
       #~ expected = File.read(filename) 
       expected = nil
-      File.open(filename, @readoption){|file| expected = file.read }
-      full_message = build_message(message, "<?> expected (#{filename}) but was\n<?>.\n", expected, actual).to_s
+      File.open(filename, 'r', :encoding => encoding ){|file| expected = file.read }
+      #~ full_message = build_message(message, "<?> expected (#{filename}) but was\n<?>.\n", expected, actual).to_s
+      full_message = '' #main message build from assert_equal
     else
       full_message = "Reference file <#{filename}> missing"
     end
 
     #Write the real result to a file if a failure folder is given.
-    if folder_for_failure and expected  != actual
-      FileUtils.makedirs(folder_for_failure) if ! File.directory?(folder_for_failure)
-      File.open( "#{folder_for_failure}/#{File.basename(filename)}", 'w'){|f|
+    if @folder_for_failure != false and expected  != actual
+      folder_for_failure = @folder_for_failure || FOLDER_FOR_FAILURE 
+      FileUtils.makedirs(folder_for_failure) unless File.directory?(folder_for_failure)
+      File.open( "#{folder_for_failure}/#{File.basename(filename)}", 'w', :encoding => encoding){|f|
         f << actual
       }
       full_message << "\n\t-> Build <#{folder_for_failure}/#{File.basename(filename)}>"
     end
 
+    #Will not work with Ruby 1.9.1/1.9.2. 
+    # -> assert( false, full_message  )
     if File.exist?(filename)
+      #Use the standard assertion to get the layouted message.
+      assert_equal( expected, actual, "Result differs to file content #{filename}" + full_message )
       #~ assert_block( full_message ){ expected  == actual }
-      case RUBY_VERSION
-        when /^1\.8/
-          assert_block( full_message ){ expected  == actual }
-        when /^1.9/
-          #ruby 1.9: Add "\nExpected block to return true value." to message with assert_block
-          assert( expected  == actual, full_message )
-        end
     else
-      case RUBY_VERSION
-        when /^1\.8/
-          assert_block( full_message ){ false }
-        when /^1.9/
-          #ruby 1.9: Add "\nExpected block to return true value." to message with assert_block
-          assert( false, full_message  )
-        end
+      assert_block( full_message ){ false }
+      #~ assert_equal( expected, actual, full_message )
     end
   end
+=begin rdoc
+Make filename conversion.
+
+The filename may contains some parameters in <x>. _x_ may be:
+* c - test class name
+* m - methodname from caller[level]
+* cm - test class name - methodname
+
+Parameter 'level' is needed to get the method.
+
+Example:
+
+  class MyTest < Test::Unit::TestCase
+    def test_xx
+      assert_equal_filecontent( "<m>.txt", mycode )
+    end
+  end 
+
+The caller stack will be
+  ___lib/more_unit_test/assert_equal_filecontent.rb:112:in `assert_equal_filecontent'
+  quicktest.rb:13:in `test_xx'
+  ___test-unit-2.4.0/lib/test/unit/testcase.rb:531:in `run_test'
+
+The result with default level 1 is 'test_xx' - the method from your test.
+
+=end
+  def  build_filename(filename, level = 1)
+    method = caller[level].match(/^(.+?):(\d+)(?::in `(.*)')?/)[3]  #methodname
+    filename.gsub(/<.*?>/){ |hit|
+      case hit
+        when '<c>'; self.class.name
+        when '<m>'; method
+        when '<cm>'; "#{self.class}-#{method}" #methodname
+        else; raise ArgumentError, "Undefined option #{hit} in filename #{filename}"
+      end
+    }.sub(/block (\(\d+ levels\) )?in /,'')
+    
+  end
   #
 end
+
+__END__
+
+Ziel:
+Angabe der expected-Datei vereinfachen.
+Generieren aus classe/methode des Aufrufers.
+
+    "#{self.class}-#{caller.first.match(/^(.+?):(\d+)(?::in `(.*)')?/)[3]}
+
+Ben�tigt:
+* extension
+* variation (bei mehreren tests in methode
+* Zus�tzliche Verzeichnisname (gesetzt in class?)
+
+Idee:
+Lsg per symbol/fixnum als filename 
+Dann filename = "#{self.class}-#{caller.first.match(/^(.+?):(\d+)(?::in `(.*)')?/)[3]}_#{filename}"
+Aber: extension?
+
+  class Test_x << Test::Unit::TestCase
+    def test_xx
+      assert_equal_filecontent( :var1, actual ) #-> Test_x-test_xx-var1
+      assert_equal_filecontent( 1, actual )       #-> Test_x-test_xx-1
+    end
+  end
+
+Idee 2:
+analog strftime.
+Nur ein parameter ben�tigt.
+
+* <c> - class
+* <m> - method
+* <cm> - class-method
+* <p> - predefined path
+* M�glichkeiten: * <>
+  class Test_x << Test::Unit::TestCase
+    def test_xx
+      assert_equal_filecontent( 'expected/$$_var1', actual ) #-> Test_x-test_xx-var1
+      assert_equal_filecontent( 'expected/$$_1', actual )       #-> Test_x-test_xx-1
+    end
+  end
+

data/lib/more_unit_test/assert_stdout.rb

@@ -1,44 +1,51 @@
-#
-#Add some funcionality to check stdout and stderr-output with test/unit.
-#
-#Example:
-#  require 'assert_stdout'
-#  class MyTest < Test::Unit::TestCase  
-#    #This is a method and I wnat to test the screen output.
-#    def any_output()
-#      puts "Just some output"
-#    end
-#    def test_stdout_ok()
-#      assert_stdout("Just some output\n", proc{ any_output()} )
-#      assert_stdout_block("Just some output\n"){ any_output() }
-#    end
-#  end
-#
-#Please be aware:
-#Normally you should not test the output of methods, but the result of methods.
-#
-require 'test/unit'
-module Test::Unit
+=begin rdoc
+Add some functionality to check stdout and stderr-output with test/unit.
 
-#Class to catch the std output and stderr
-class Catch_IO  < String
-  #Receive content
-  def write( cont )
-    self  << cont
+Example:
+  require 'assert_stdout'
+  class MyTest < Test::Unit::TestCase  
+    #This is a method and I wnat to test the screen output.
+    def any_output()
+      puts "Just some output"
+    end
+    def test_stdout_ok()
+      assert_stdout("Just some output\n", proc{ any_output()} )
+      assert_stdout_block("Just some output\n"){ any_output() }
+    end
   end
-end  #MyIO
 
-#
-#Extend the class TestCase with additional methods/assertions
-#
-class TestCase
-  #Catch stdout for a given procedure (Proc-Element).
-  def catch_stdout( procedure )
-    $stdout = output = Catch_IO.new #temporary copy
-    procedure.call
-    $stdout = STDOUT
-    output
-  end
+Please be aware:
+Normally you should not test the output of methods, but the result of methods.
+=end
+require 'test/unit'
+module Test
+  module Unit
+    #Class to catch the std output and stderr
+    class Catch_IO  < String
+      #Receive content
+      def write( cont )
+        self  << cont
+      end
+    end  #MyIO
+
+=begin rdoc
+Extend the class TestCase with additional methods/assertions
+
+Details see
+* Test::Unit::TestCase#assert_stdout
+* Test::Unit::TestCase#assert_stdout_block
+* Test::Unit::TestCase#assert_stderr
+* Test::Unit::TestCase#assert_stderr_block
+
+=end
+    class TestCase
+      #Catch stdout for a given procedure (Proc-Element).
+      def catch_stdout( procedure )
+        $stdout = output = Catch_IO.new #temporary copy
+        procedure.call
+        $stdout = STDOUT
+        output
+      end
 =begin rdoc  
   Compare the stdout-output with your exception.
   
@@ -53,17 +60,17 @@ class TestCase
         end
       end
 =end
-  def assert_stdout( expected, actual, message = nil )
-    if actual.respond_to?(:call)
-      output = catch_stdout( actual )
-      full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
-      assert_block( full_message ){ expected  == output }
-    else
-      raise 'no Proc-object given'
-      full_message = build_message(message, "<?> expected in stdout, but no Proc-object is given to test.\n", expected )
-      assert_block( full_message ){ false } #force error
-    end
-  end
+      def assert_stdout( expected, actual, message = nil )
+        if actual.respond_to?(:call)
+          output = catch_stdout( actual )
+          full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
+          assert_block( full_message ){ expected  == output }
+        else
+          raise 'no Proc-object given'
+          full_message = build_message(message, "<?> expected in stdout, but no Proc-object is given to test.\n", expected )
+          assert_block( full_message ){ false } #force error
+        end
+      end
 =begin rdoc  
 Compare the stdout-output of a given block with your exception.
 
@@ -75,32 +82,32 @@ Example:
     end
   end
 =end  
-  def assert_stdout_block( expected, message = nil )
-    previous_stdout = $stdout
-    previous_STDOUT = STDOUT
-    if block_given? 
-      $stdout = output = Catch_IO.new #temporary copy
-      #~ STDOUT.reopen($stdout)
-      yield
-      $stdout = previous_stdout
-      #~ STDOUT.reopen(previous_STDOUT)
-      full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
-      assert_block( full_message ){ expected  == output }
-    else
-      raise 'no block given'
-      full_message = build_message(message, "<?> expected in stdout, but no block to test.\n", expected )
-      assert_block( full_message ){ false }
-    end
-  end
+      def assert_stdout_block( expected, message = nil )
+        previous_stdout = $stdout
+        previous_STDOUT = STDOUT
+        if block_given? 
+          $stdout = output = Catch_IO.new #temporary copy
+          #~ STDOUT.reopen($stdout)
+          yield
+          $stdout = previous_stdout
+          #~ STDOUT.reopen(previous_STDOUT)
+          full_message = build_message(message, "<?> expected in stdout, but was\n<?>.\n", expected, output)
+          assert_block( full_message ){ expected  == output }
+        else
+          raise 'no block given'
+          full_message = build_message(message, "<?> expected in stdout, but no block to test.\n", expected )
+          assert_block( full_message ){ false }
+        end
+      end
 =begin rdoc  
 Catch stderr for a given procedure (Proc-Element).
 =end
-  def catch_stderr( procedure )
-    $stderr = output = Catch_IO.new #temporary copy
-    procedure.call
-    $stderr = STDERR
-    output
-  end
+      def catch_stderr( procedure )
+        $stderr = output = Catch_IO.new #temporary copy
+        procedure.call
+        $stderr = STDERR
+        output
+      end
 =begin rdoc
 Compare the stderr-output with your exception.
 
@@ -119,17 +126,17 @@ Example:
     end
   end
 =end
-  def assert_stderr( expected, actual, message = nil )
-    if actual.respond_to?(:call)
-      output = catch_stderr( actual )
-      full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
-      assert_block( full_message ){ expected  == output }
-    else
-      raise 'no Proc-object given'
-      full_message = build_message(message, "<?> expected in stderr, but no Proc-object is given to test.\n", expected )
-      assert_block( full_message ){ false } #force error
-    end
-  end
+      def assert_stderr( expected, actual, message = nil )
+        if actual.respond_to?(:call)
+          output = catch_stderr( actual )
+          full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
+          assert_block( full_message ){ expected  == output }
+        else
+          raise 'no Proc-object given'
+          full_message = build_message(message, "<?> expected in stderr, but no Proc-object is given to test.\n", expected )
+          assert_block( full_message ){ false } #force error
+        end
+      end
 =begin rdoc
 Compare the stderr-output with your exception.
 
@@ -145,20 +152,21 @@ Example:
     end
   end
 =end
-  def assert_stderr_block( expected, message = nil )
-    if block_given? 
-      $stderr = output = Catch_IO.new #temporary copy
-      yield
-      $stderr = STDERR
-      full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
-      assert_block( full_message ){ expected  == output }
-    else
-      raise 'no block given'
-      full_message = build_message(message, "<?> expected in stderr, but no block to test.\n", expected )
-      assert_block( full_message ){ false }
-    end
-  end
-end   #class TestCase
+      def assert_stderr_block( expected, message = nil )
+        if block_given? 
+          $stderr = output = Catch_IO.new #temporary copy
+          yield
+          $stderr = STDERR
+          full_message = build_message(message, "<?> expected in stderr, but was\n<?>.\n", expected, output)
+          assert_block( full_message ){ expected  == output }
+        else
+          raise 'no block given'
+          full_message = build_message(message, "<?> expected in stderr, but no block to test.\n", expected )
+          assert_block( full_message ){ false }
+        end
+      end
+    end   #class TestCase
+  end   #module Unit
 end   #module Test::Unit
 
 __END__

data/readme

@@ -0,0 +1,53 @@
+=Extend test/unit
+The more_unit_test-package extends test/unit with some additional tests
+to handle stdout/stderr and big strings.
+
+==more_unit_test/assert_equal_filecontent.rb
+
+Compare expected result with file content
+
+Usefull, if you compare long strings in your tests.
+
+Details see Test::Unit::TestCase#assert_equal_filecontent
+
+==more_unit_test/assert_stdout.rb
+Test for stdout/stderr.
+
+Details see
+* Test::Unit::TestCase#assert_stdout
+* Test::Unit::TestCase#assert_stdout_block
+* Test::Unit::TestCase#assert_stderr
+* Test::Unit::TestCase#assert_stderr_block
+
+
+
+=Version history:
+0.0.1:
+* Initial version.
+
+0.0.2:
+* modified folder structure
+* more documentation.
+* published at gemcutter
+
+0.1.0 2010-02-07
+* Restructured lib-directory
+* Restructured the tests
+* removed catch_output (is available in knut_tools.gem)
+
+0.1.1 2010-05-03
+* first steps to Ruby 1.9
+
+0.1.2 2011-02-17
+* Add Test::Unit::TestCase#readoption= for read options of expected-file
+
+0.1.3 
+* Correction ruby 1.9-specialities (was there a problem with 1.9.1?)
+
+0.2.0 2015-02-02
+* Remove _parameter folder_for_failure_ from Test::Unit::TestCase#assert_equal_filecontent
+  * Advantage: interface is same as _assert_equal_
+  * folder_for_failure can be set with Test::Unit::TestCase#folder_for_failure=
+* Use encoding of test-result to write to failure-file.
+* Test::Unit::TestCase#assert_equal_filecontent: use assert_equal to layout failure message
+* Enable Test::Unit::TestCase#assert_equal_filecontent to define dynamic filenames, based on test method name.

data/unittest/test_assert_equal_filecontent.rb

@@ -1,13 +1,8 @@
 #~ #encoding: utf-8
 gem 'test-unit', '>= 2.1.1' #defines omit, pend...
 require 'test/unit'
-if $0 == __FILE__
-  if RUBY_VERSION == '1.9.1'  
-  $:.unshift("../lib")
-  else
-  $: << "../lib"
-  end
-end
+
+$:.unshift("../lib") if $0 == __FILE__
 require "more_unit_test/assert_equal_filecontent.rb"
 
 #Some content to be tested.
@@ -36,7 +31,33 @@ $folder_for_failure  = File.dirname(__FILE__) + '/tmp_failure'
 #~ require 'test/testunit/test_assertions'
 
 #
-class MyTest < Test::Unit::TestCase
+class Test_equal_filecontent_filename < Test::Unit::TestCase
+  def test_normal
+    assert_equal('x', build_filename('x'))
+  end
+  def test_c
+    assert_equal(self.class.to_s, build_filename('<c>'))
+  end
+  def test_m
+    assert_equal(__method__.to_s, build_filename('<m>',0))
+  end
+  def test_cm
+    assert_equal("#{self.class}-#{__method__}", build_filename('<cm>',0))
+  end
+
+  def test_m_cascaded
+    assert_nothing_raised{
+      assert_equal(__method__.to_s, build_filename('<m>',0))
+    }
+    assert_nothing_raised{
+      assert_nothing_raised{
+        assert_equal(__method__.to_s, build_filename('<m>',0))
+      }
+    }
+  end
+end #Test_equal_filecontent_filename
+
+class Test_equal_filecontent < Test::Unit::TestCase
   
   #Machte Probleme ohne gem laden
   #~ case RUBY_VERSION 
@@ -49,61 +70,132 @@ class MyTest < Test::Unit::TestCase
       #~ AssertionFailedError = Test::Unit::AssertionFailedError
   #~ end
   AssertionFailedError = Test::Unit::AssertionFailedError
-
-  def test_ok()
-    #Build reference data
-    self.readoption = 'r:cp1252' unless RUBY_VERSION <= '1.8'
+  
+  #Build reference data
+  def self.startup()
     FileUtils.makedirs($expected)
     File.open("#{$expected}/test.txt", 'w'){|f| f << DUMMYTEXT }
+    File.open("#{$expected}/test_utf.txt", 'w:utf-8'){|f| f << DUMMYTEXT_utf }
+    File.open("#{$expected}/test_build.txt", 'w'){|f| f << DUMMYTEXT*2 }
+  end
+  def self.shutdown()
+    #~ File.delete("#{$expected}/test.txt")
+    #~ File.delete("#{$expected}/test_utf.txt")
+    #~ File.delete("#{$expected}/test_build.txt")
+    #~ Dir.delete("#{$expected}")
+    
+    FileUtils.rmtree($expected)
+    FileUtils.rmtree($folder_for_failure)
+    FileUtils.rmtree(FOLDER_FOR_FAILURE)
+  end
+  
+  def test_ok()
+    #Build reference data
+    self.read_encoding = 'cp1252' unless RUBY_VERSION <= '1.8'
     #Make test
     assert_equal_filecontent( "#{$expected}/test.txt", DUMMYTEXT )
   end
   
   def test_utf()
     omit_if(RUBY_VERSION <= '1.8', "No encoding check for ruby #{RUBY_VERSION}")
-    #Build reference data
-    FileUtils.makedirs($expected)
-    File.open("#{$expected}/test_utf.txt", 'w:utf-8'){|f| f << DUMMYTEXT_utf }
     #Make test
-    self.readoption = 'r:utf-8'
+    self.read_encoding = 'utf-8' #default, not necessary
     assert_equal_filecontent( "#{$expected}/test_utf.txt", DUMMYTEXT_utf )
   end
 
 #Check error
   def test_no_reference_file()
     
+    self.folder_for_failure = false  #inactivate error/reference file creation.
     #Check exception and get the message
     msg = assert_raise( AssertionFailedError ){
-      assert_equal_filecontent( "#{$expected}/not_available.txt", DUMMYTEXT, nil )
+      assert_equal_filecontent( "#{$expected}/not_available.txt", DUMMYTEXT )
     }    
-    #fixme 1.9 assert_block ändert wert
-    case RUBY_VERSION 
-      when /1.9/
-        pend("Check for Ruby-Version #{RUBY_VERSION }")
-        assert_equal( "Reference file <#{$expected}/not_available.txt> missing.\nExpected block to return true value.", msg.to_s)
-      when /1.8/
-        assert_equal( "Reference file <#{$expected}/not_available.txt> missing", msg.to_s)
-      else
-        notify("Ruby-Version #{RUBY_VERSION } undefined")
-    end
+    assert_instance_of(Test::Unit::AssertionFailedError, msg)
+    assert_equal( "Reference file <#{$expected}/not_available.txt> missing", msg.to_s)
   end
   #Check, if "Failure" is created.
-  def test_build_reference_file()
-    #Initial expected file
-    FileUtils.makedirs($expected)
-    File.open("#{$expected}/test_build.txt", 'w'){|f| f << DUMMYTEXT*2 }
-    #
+  def test_build_reference_file_default_path()
+    
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raise( AssertionFailedError ){
+      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Result differs to file content #{$expected}/test_build.txt\n\t-> Build <#{FOLDER_FOR_FAILURE}/test_build.txt}m, 
+                        msg.to_s )
+    
+    #Check for file with correkt result
+    assert_true(File.exist?("#{FOLDER_FOR_FAILURE}/test_build.txt" ))
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/test_build.txt", DUMMYTEXT, nil )
+  end
+  
+  #Check, if "Failure" is created.
+  def test_build_reference_file_with_path()
     
+    self.folder_for_failure = $folder_for_failure #set other failure folder for assertion in this test
     #First check. There is a difference, in failure we get the correct result
     msg = assert_raise( AssertionFailedError ){
-      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT, $folder_for_failure )
+      assert_equal_filecontent( "#{$expected}/test_build.txt", DUMMYTEXT )
     }
-    assert_match( %r{.*expected \(#{$expected}/test_build.txt\) but was.*-> Build <#{$folder_for_failure}/test_build.txt}m, 
+    assert_match( %r{Result differs to file content #{$expected}/test_build.txt\n\t-> Build <#{$folder_for_failure}/test_build.txt}m, 
                         msg.to_s )
     
     #Check for file with correkt result
-    assert_equal(true, File.exist?("#{$folder_for_failure}/test_build.txt" ))
+    assert_true(File.exist?("#{$folder_for_failure}/test_build.txt" ))
     #Check with new file (normally you would copy the file to $expected
     assert_equal_filecontent( "#{$folder_for_failure}/test_build.txt", DUMMYTEXT, nil )
   end
-end #class MyTest
+  def test_build_reference_file_parameter_error()    
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raise( ArgumentError ){
+      assert_equal_filecontent( "<??>.txt", DUMMYTEXT )
+    }
+  end
+  def test_build_reference_file_parameter_c()    
+    filename = self.class.name
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raise( AssertionFailedError ){
+      assert_equal_filecontent( "#{$expected}/<c>.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Reference file <#{$expected}/#{filename}.txt> missing.*-> Build <#{FOLDER_FOR_FAILURE}/#{filename}.txt}m, 
+                        msg.to_s )
+
+    #Check for file with correkt result
+    assert_true(File.exist?("#{FOLDER_FOR_FAILURE}/#{filename}.txt" ))
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/#{filename}.txt", DUMMYTEXT, nil )
+  end
+  def test_build_reference_file_parameter_m()
+    #~ pend "filename <m>"
+    filename = __method__
+    #First check. There is a difference, in failure we get the correct result
+    msg = assert_raise( AssertionFailedError ){
+      assert_equal_filecontent( "#{$expected}/<m>.txt", DUMMYTEXT )
+    }
+    assert_match( %r{Reference file <#{$expected}/#{filename}.txt> missing.*-> Build <#{FOLDER_FOR_FAILURE}/#{filename}.txt}m, 
+                        msg.to_s )
+
+
+    #Check for file with correkt result
+    assert_true(File.exist?("#{FOLDER_FOR_FAILURE}/#{filename}.txt" ))
+    #Check with new file (normally you would copy the file to $expected
+    assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/#{filename}.txt", DUMMYTEXT, nil )
+  end
+  #~ def test_build_reference_file_parameter_cm()    
+    #~ pend "filename <cm>"
+    #~ filename = "#{self.class.name}-#{__method__}"
+    #~ #First check. There is a difference, in failure we get the correct result
+    #~ msg = assert_raise( AssertionFailedError ){
+      #~ assert_equal_filecontent( "#{$expected}/<cm>.txt", DUMMYTEXT )
+    #~ }
+    #~ assert_match( %r{Reference file <#{$expected}/#{filename}.txt> missing.*-> Build <#{FOLDER_FOR_FAILURE}/#{filename}.txt}m, 
+                        #~ msg.to_s )
+
+    #~ #Check for file with correkt result
+    #~ assert_true(File.exist?("#{FOLDER_FOR_FAILURE}/#{filename}.txt" ))
+    #~ #Check with new file (normally you would copy the file to $expected
+    #~ assert_equal_filecontent( "#{FOLDER_FOR_FAILURE}/#{filename}.txt", DUMMYTEXT, nil )
+  #~ end
+  
+end #Test_equal_filecontent 

data/unittest/test_assert_stdout.rb

@@ -63,9 +63,9 @@ class Log4rTest < Test::Unit::TestCase
   def test_alternative()
     log = Log4r::Logger.new('testlog')
     begin 
-    io = Tempfile.new(self.object_id)
+    io = Tempfile.new(self.object_id.to_s)
     rescue ArgumentError
-      omit("Tempfile error (ruby 1.9.2)")
+      omit("Tempfile error")
     end
     log.outputters << Log4r::IOOutputter.new('log_stdout', io)
     log.info('a')

metadata

@@ -1,105 +1,102 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: more_unit_test
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 2
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 0.2.0
 platform: ruby
-authors: 
+authors:
 - Knut Lickert
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-17 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: test-unit
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: knut_tools
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: knut-gempackager
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
   type: :development
-  version_requirements: *id002
-description: |
-  The more_unit_test-package extends test/unit with some additional tests:
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: knut-testtask
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: ! 'The more_unit_test-package extends test/unit with some additional
+  tests:
+
   - assert_equal_filecontent.rb: Compare expected result with file content
+
   - assert_stdout.rb: test for stdout/stderr
 
+'
 email: knut@lickert.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- readme.rd
-files: 
-- readme.rd
+extra_rdoc_files:
+- readme
+files:
 - lib/more_unit_test.rb
 - lib/more_unit_test/assert_equal_filecontent.rb
 - lib/more_unit_test/assert_stdout.rb
-- unittest/test_assert_stdout.rb
+- readme
 - unittest/test_assert_equal_filecontent.rb
-has_rdoc: true
+- unittest/test_assert_stdout.rb
 homepage: http://gems.rubypla.net/more_unit_test/
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
-- readme.rd
-require_paths: 
+- readme
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: more_unit_test
-rubygems_version: 1.3.7
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Additional assertions for big text results.
-test_files: 
+test_files:
 - unittest/test_assert_stdout.rb
 - unittest/test_assert_equal_filecontent.rb

data/readme.rd

@@ -1,32 +0,0 @@
-=Extend test/unit
-The more_unit_test-package extends test/unit with some additional tests
-to hande staou/stderr
-
-==more_unit_test/assert_equal_filecontent.rb
-
-Compare expected result with file content
-==more_unit_test/assert_stdout.rb
-Test for stdout/stderr
-
-
-
-=Version history:
-0.0.1:
-* Initial version.
-
-0.0.2:
-* modified folder structure
-* more documentation.
-* published at gemcutter
-
-0.1.0 2010-02-07
-* Restructured lib-directory
-* Restructured the tests (using knut_tools/rake/testtask.rb)
-* removed catch_output (is available in knut_tools.gem)
-
-0.1.1 2010-05-03
-* first steps to Ruby 1.9
-
-0.1.2 2011-02-17
-* Add readoption for read options of expected-file
-