test4requirements 0.1.0.alpha.2 → 0.1.0

data/lib/test4requirements/testcase.rb

@@ -40,20 +40,18 @@ Example:
 =end      
       def assign_requirement(req)
         raise RuntimeError, "No requirements defined for #{self}" unless requirements
-        requirements.assign_test(req, self.name)
+        requirements.assign_test(req, self.name, @_result)
       end
-      alias  :run_test_old :run_test
-=begin rdoc
-Add info about a successfull test to the assigned requirement.
-=end
+      
+      alias :old_run_test :run_test
       def run_test
-        run_test_old
-        #this code is left if a problem occured.
-        #in other words: if we reach this place, then the test was sucesfull
-        if requirements
-          requirements.test_successfull(self.name)
-        end #if requirements
-      end #def run_test
+        old_run_test
+        #Store successfull test run,
+        self.requirements.each{|req|
+          req.result(self.name, :ok) unless req[self.name].nil?
+        } if requirements
+      end
+      
     end #class TestCase
   end #module Unit
 end   #module Test

data/unittest/check_compatibility.rb

@@ -1,65 +1,65 @@
-=begin rdoc
-Some check routines to check the installation
-=end
-
-puts RUBY_DESCRIPTION
-
-
-gem 'test-unit'
-#~ require 'test/unit'
-require 'test/unit/version'
-
-=begin rdoc
-
-Encoding#ascii_compatible?
-
-Test::Unit::Assertions contains:
-            if string.respond_to?(:encoding) and
-                !string.encoding.ascii_compatible?
-              string = string.dup.force_encoding("ASCII-8BIT")
-            end
-Probably added with test-unit 2.2.0
-http://rubyforge.org/forum/forum.php?forum_id=38792
-   support not ASCII compatible string diff.
-   
-Encoding#ascii_compatible? was added with:     
-http://redmine.ruby-lang.org/issues/show/1900
-Applied in changeset r24480.
-
-http://www.ruby-forum.com/topic/192885
-
-
-=end
-if Test::Unit::VERSION >= '2.3.1'
-    if ! 'string'.encoding.respond_to?(:'ascii_compatible?')
-      puts "Encoding#ascii_compatible? not defined - Test::Unit #{Test::Unit::VERSION} needs it"
-    end
-end
-
-#~ gem 'test-unit', '= 2.3.1'
-#~ require 'test/unit' 
-#~ class Test_Requirement < Test::Unit::TestCase
-  #~ def test_interface_ok()
-    #~ assert_equal('a', 'b')
-  #~ end
-#~ end
-  
-
-__END__
-RUBY_VERSION 
-RUBY_PATCHLEVEL
-RUBY_RELEASE_DATE
-
-Worked fine:
-gem 'test-unit', '= 2.1.1'
-
-
-gem 'test-unit', '= 2.3.1'
-ruby 1.9.1
-
-
-            if string.respond_to?(:encoding) and
-                !string.encoding.ascii_compatible?
-              string = string.dup.force_encoding("ASCII-8BIT")
-            end
-
+=begin rdoc
+Some check routines to check the installation
+=end
+
+puts RUBY_DESCRIPTION
+
+
+gem 'test-unit'
+#~ require 'test/unit'
+require 'test/unit/version'
+
+=begin rdoc
+
+Encoding#ascii_compatible?
+
+Test::Unit::Assertions contains:
+            if string.respond_to?(:encoding) and
+                !string.encoding.ascii_compatible?
+              string = string.dup.force_encoding("ASCII-8BIT")
+            end
+Probably added with test-unit 2.2.0
+http://rubyforge.org/forum/forum.php?forum_id=38792
+   support not ASCII compatible string diff.
+   
+Encoding#ascii_compatible? was added with:     
+http://redmine.ruby-lang.org/issues/show/1900
+Applied in changeset r24480.
+
+http://www.ruby-forum.com/topic/192885
+
+
+=end
+if Test::Unit::VERSION >= '2.3.1'
+    if ! 'string'.encoding.respond_to?(:'ascii_compatible?')
+      puts "Encoding#ascii_compatible? not defined - Test::Unit #{Test::Unit::VERSION} needs it"
+    end
+end
+
+#~ gem 'test-unit', '= 2.3.1'
+#~ require 'test/unit' 
+#~ class Test_Requirement < Test::Unit::TestCase
+  #~ def test_interface_ok()
+    #~ assert_equal('a', 'b')
+  #~ end
+#~ end
+  
+
+__END__
+RUBY_VERSION 
+RUBY_PATCHLEVEL
+RUBY_RELEASE_DATE
+
+Worked fine:
+gem 'test-unit', '= 2.1.1'
+
+
+gem 'test-unit', '= 2.3.1'
+ruby 1.9.1
+
+
+            if string.respond_to?(:encoding) and
+                !string.encoding.ascii_compatible?
+              string = string.dup.force_encoding("ASCII-8BIT")
+            end
+

data/unittest/unittest_requirement.rb

@@ -1,9 +1,10 @@
 $:.unshift('../lib')
-gem 'test-unit'
+gem 'test-unit', '<= 2.1.1' if RUBY_VERSION == '1.9.1'
 require 'test/unit'
 require 'test4requirements/requirement.rb'
 include Test4requirements
 
+
 class Test_Requirement < Test::Unit::TestCase
   
   def test_interface_ok()
@@ -24,59 +25,67 @@ class Test_Requirement < Test::Unit::TestCase
     assert_nothing_raised { req = Requirement.new(1, :reference => 'ref')}
     assert_equal('ref', req.reference)
   end  
+  def test_interface_option_key()
+    req = nil
+    assert_nothing_raised { req = Requirement.new(1, :key => 1)}
+    assert_raise(ArgumentError, "ambiguous key") { Requirement.new(1, :key => 2)}
+  end  
   def test_interface_option()
     assert_raise(ArgumentError) { Requirement.new(1, :undefined_key => 'desc') }
   end
   
   def test_no_test_assignment()
     req = Requirement.new(1)
-    assert_false(req.tested?)
+    assert_false(req.test_defined?)
     assert_nil(req.successfull?)
   end
 
   def test_test_assignment()
     req = Requirement.new(1)
     req.test='loc'
-    assert_equal(1,req.tested?)
+    assert_equal(1,req.test_defined?)
     req.test='loc'
-    assert_equal(1,req.tested?, "No duplicate definition")
+    assert_equal(1,req.test_defined?, "No duplicate definition")
     req.test='loc2'
-    assert_equal(2,req.tested?, "Two TestCases")
+    assert_equal(2,req.test_defined?, "Two TestCases")
     
-    assert_false(req.successfull?)
+    assert_nil(req.successfull?)
   end
 
   def test_test_success()
     req = Requirement.new(1)
     req.test='loc'
-    assert_equal(1,req.tested?)
-    assert_false(req.successfull?)
+    assert_equal(1,req.test_defined?)
+    assert_nil(req.successfull?)
     
-    req.successfull_test('loc')
-    assert_equal(1,req.tested?)
+    req.result('loc', :ok)
+    assert_equal(1,req.test_defined?)
     assert_true(req.successfull?)
   end
 
   def test_test_success_without_assignment()
     req = Requirement.new(1)
-    assert_false(req.tested?)
+    assert_false(req.test_defined?)
     assert_nil(req.successfull?)
     
-    req.successfull_test('loc')
-    assert_equal(1,req.tested?)
+    #~ req.test = 'loc'
+    req.result('loc', :ok)
+    assert_equal(1,req.test_defined?)
     assert_true(req.successfull?)
   end
 
   def test_2test_success()
     req = Requirement.new(1)
     req.test='loc'
-    assert_equal(1,req.tested?)
-    assert_false(req.successfull?)
+    assert_equal(1,req.test_defined?)
+    assert_nil(req.successfull?, 'Test was not executed')
     
-    req.successfull_test('loc2')
-    assert_equal(2,req.tested?)
-    assert_false(req.successfull?, "One of the tests was unsuccessfull")
+    req.test = 'loc2'
+    req.result('loc2', :ok)
+    assert_equal(2,req.test_defined?)
+    assert_nil(req.successfull?, "One of the tests was not done")
+    req.result('loc', :ok)
+    assert_true(req.successfull?)
   end
-
   
 end

data/unittest/unittest_requirementlist.rb

@@ -1,4 +1,5 @@
 $:.unshift('../lib')
+gem 'test-unit', '<= 2.1.1' if RUBY_VERSION == '1.9.1'
 gem 'test-unit'
 require 'test/unit'
 require 'log4r'
@@ -13,72 +14,87 @@ RequirementList.report_type_default = nil
 class Test_RequirementList < Test::Unit::TestCase
   
   def test_interface()
-    assert_nothing_raised { RequirementList.new()}
-    assert_nothing_raised { RequirementList.new(1)}
-    assert_nothing_raised { RequirementList.new(Requirement.new(1))}
+    assert_raise(ArgumentError) { RequirementList.new()}
+    assert_nothing_raised { RequirementList.new(:reqId)}
+    assert_nothing_raised { RequirementList.new(:reqId,1)}
+    assert_nothing_raised { RequirementList.new(:reqId, Requirement.new(1))}
   end
   
   def test_add_requirement()
-    req = RequirementList.new()
-    assert_nothing_raised { req << Requirement.new(1) }
-    assert_raise(ArgumentError) { req << 1 }
+    req = RequirementList.new(:reqId)
+    assert_nothing_raised { req << Requirement.new(:req1) }
+    assert_raise(ArgumentError) { req << :req1 }
+    assert_equal(1, req.each.size)
+    assert_equal(:req1, req.each.first.key)
   end
-  
+
+  def test_load()
+    req = RequirementList.new(:reqId)
+    #~ pend('load')
+    assert_nothing_raised { req.load( {
+          req1: {
+            description: 'What is required',
+            reference: 'Customer Requirement, Version 2011-08-02, page 12'},
+          req2: {
+            description: 'What is required',
+            reference: 'Customer Requirement, Version 2011-08-02, page 13'}
+        })
+    }
+    assert_equal(2, req.each.size)
+    assert_equal(:req1, req.each.first.key)
+    assert_equal(:req2, req.each.last.key)
+    
+  end
+
   def test_interface_double_definition()
-    assert_raise(ArgumentError) { RequirementList.new(1, 1) }
-    assert_raise(ArgumentError) { RequirementList.new(Requirement.new(1),1)}
-    assert_raise(ArgumentError) { RequirementList.new(Requirement.new(1),Requirement.new(1))}
+    assert_raise(ArgumentError) { RequirementList.new(:reqId, 1, 1) }
+    assert_raise(ArgumentError) { RequirementList.new(:reqId, Requirement.new(1),1)}
+    assert_raise(ArgumentError) { RequirementList.new(:reqId, Requirement.new(1),Requirement.new(1))}
   end
   
   def test_unassigned_test()
-    req = RequirementList.new()
+    req = RequirementList.new(:reqId)
     assert_raise(ArgumentError, "Unkwown req. can't be assigned") { req.assign_test(1, 'loc')}
     assert_equal(nil, req[1], "Unassigned test returns nil")
     #~ assert_false(req[1].tested?)
     #~ assert_false(req[1].successfull?)
   end
   def test_assign_test()
-    req = RequirementList.new()
-    assert_nothing_raised("Assign requirement") { req << Requirement.new(1) }
-    assert_nothing_raised("Assign test") { req.assign_test(1, 'loc') }
-    assert_instance_of(Requirement, req[1])
-    assert_equal(false, req[1]['loc'])
-    assert_equal(1,req[1].tested?)
-    assert_false(req[1].successfull?)
+    req = RequirementList.new(:reqId)
+    assert_nothing_raised("Assign requirement") { req << Requirement.new(:req1) }
+    assert_nothing_raised("Assign test") { req.assign_test(:req1, 'loc', Test::Unit::TestResult.new()) }
+    assert_instance_of(Requirement, req[:req1])
+    assert_equal(false, req[:req1]['loc'])
+    assert_equal(1,req[:req1].test_defined?)
+    assert_nil(req[:req1].successfull?)
   end
 
   def test_successfull_test()
-    req = RequirementList.new()
+    req = RequirementList.new(:reqId)
     req << Requirement.new(1)
-    req.assign_test(1, 'loc')  #not neccesary
+    req.assign_test(1, 'loc', Test::Unit::TestResult.new())  #not neccesary
     assert_false(req[1]['loc'])
     
-    assert_nothing_raised("Successfull test") { req.test_successfull('loc') }
+    assert_nothing_raised("Successfull test") { req[1].result('loc',:ok) }
     assert_instance_of(Requirement, req[1])
-    assert_equal(1,req[1].tested?)
+    assert_equal(1,req[1].test_defined?)
     assert_true(req[1]['loc'])
     assert_true(req[1].successfull?)
   end
   
-  def test_successfull_test_without_assignment()
-    req = RequirementList.new()
-    req << Requirement.new(1)
-    
-    assert_nothing_raised("Successfull test") { req.test_successfull('loc') }
-    assert_instance_of(Requirement, req[1])
-    assert_false(req[1].tested?)
-    assert_nil(req[1].successfull?)
-  end
   
   def test_unsuccessfull_test()
-    req = RequirementList.new()
+    req = RequirementList.new(:reqId)
     req << Requirement.new(1)
-    req.assign_test(1, 'loc') 
+    req.assign_test(1, 'loc', Test::Unit::TestResult.new()) 
     assert_instance_of(Requirement, req[1])
     assert_equal(false, req[1]['loc'])
-    assert_equal(1,req[1].tested?)
+    assert_equal(1,req[1].test_defined?)
+    assert_nil(req[1].successfull?)
+    req[1].result('loc', Test::Unit::Failure.new(1,2,3))
     assert_false(req[1].successfull?)
   end
 
 end
 
+

data/unittest/{unittest_requirementlist_overview.rb → unittest_requirementlist_with_tests.rb}

@@ -1,199 +1,257 @@
-$:.unshift('../lib')
-#~ gem 'test-unit'
-#~ require 'test/unit'
-require 'test4requirements.rb'
-include Test4requirements
-
-RequirementList.report_type_default = nil
-
-#IO to catch stdout in TestRunner
-IO_Catcher = Class.new(IO){ def write(arg);end }.new(2, 'w')  
-
-class Test_RequirementList_Overview_without_test < Test::Unit::TestCase
-  def setup
-    @reqs = RequirementList.new(1,2,3)
-    @testcase = Class.new(Test::Unit::TestCase)
-    @testcase.requirements=  @reqs
-    #~ @testcase.suite() #run tests
-  end
-  
-  def test_overview_default()
-    assert_kind_of(Hash, @reqs.overview)
-    assert_equal([1,2,3], @reqs.overview.keys)
-    @reqs.overview.each{|key,req| assert_nil(req) }
-  end
-
-  #same as default
-  def test_overview_nil()
-    @reqs.report_type = nil
-    assert_kind_of(Hash, @reqs.overview)
-    assert_equal([1,2,3], @reqs.overview.keys)
-  end
-
-  def test_overview_txt()
-    @reqs.report_type = :txt
-    assert_kind_of(Array, @reqs.overview)
-    assert_equal(3, @reqs.overview.size)
-    assert_equal(["Requirement 1 was not tested",
-                       "Requirement 2 was not tested",
-                       "Requirement 3 was not tested"], @reqs.overview)
-  end
-
-  def test_overview_unknown()
-    assert_raise(ArgumentError){@reqs.report_type = :unknown}
-    assert_nothing_raised{@reqs.overview}
-    assert_raise(ArgumentError){@reqs.overview(:unknown)}
-  end
-end
-
-
-class Test_RequirementList_Overview_with_test < Test::Unit::TestCase
-  def setup
-    @reqs = RequirementList.new(:req1,:req2,:req3)
-    @testcase = Class.new(Test::Unit::TestCase) do
-      #Set class name. Normally class name.
-      def self.name;'Test_ReqList';end
-      
-      def test_1()
-        assign_requirement(:req1)  #this test is testing requirement req1
-        assert_equal(2,1+1)
-      end
-      def test_2()
-        assign_requirement(:req2)  #this test is testing requirement req2 without success
-        assert_equal(3,1+1)
-      end
-    end
-    @testcase.requirements=  @reqs
-    
-    suite = @testcase.suite #run tests
-    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
-  end
-  
-  def test_testcase_definition()
-    assert_true(@testcase.instance_methods.include?(:test_1))
-    assert_true(@testcase.instance_methods.include?(:test_2))
-    #~ assert_true(@testcase.respond_to?(:test_1))
-    #~ assert_true(@testcase.respond_to?(:test_2))
-  end
-  
-  def test_overview_default()
-    assert_kind_of(Hash, @reqs.overview)
-    assert_equal([:req1,:req2,:req3], @reqs.overview.keys)
-    assert_equal([true,false,nil], @reqs.overview.values)
-  end
-
-  #same as default
-  def test_overview_nil()
-    @reqs.report_type = nil
-    assert_kind_of(Hash, @reqs.overview)
-    assert_equal([true,false,nil], @reqs.overview.values)
-  end
-
-  def test_overview_txt()
-    @reqs.report_type = :txt
-    assert_kind_of(Array, @reqs.overview)
-    assert_equal(3, @reqs.overview.size)
-    assert_equal(["Requirement req1 was successfull tested (test_1(Test_ReqList))",
-                       "Requirement req2 was unsuccessfull tested (test_2(Test_ReqList))",
-                       "Requirement req3 was not tested"
-                    ], @reqs.overview)
-  end
-end
-
-
-
-class Test_two_tests_for_one_requirement_successfull  < Test::Unit::TestCase
-  def setup
-    @reqs = reqs = RequirementList.new(:req1)
-    testcase = Class.new(Test::Unit::TestCase) do
-      #Set class name. Normally class name.
-      def self.name;'Test_ReqList';end
-      self.requirements=  reqs
-      
-      def test_1()
-        assign_requirement(:req1)  #this test is testing requirement req1
-        assert_equal(2,1+1)
-      end
-      def test_2()
-        assign_requirement(:req1)  #this test is testing requirement req2 without success
-        assert_equal(2,1+1)
-      end
-    end
-    
-    suite = testcase.suite #run tests
-    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
-  end
-  def test_duplicate_test  
-    assert_equal([:req1], @reqs.overview.keys)
-    assert_equal([true], @reqs.overview.values)
-  end
-  def test_overview_txt()
-    @reqs.report_type = :txt  
-     assert_equal(["Requirement req1 was successfull tested (test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
-  end
-end
-
-class Test_two_tests_for_one_requirement_unsuccessfull < Test::Unit::TestCase
-  def setup
-    @reqs = reqs = RequirementList.new(:req1)
-    testcase = Class.new(Test::Unit::TestCase) do
-      #Set class name. Normally class name.
-      def self.name;'Test_ReqList';end
-      self.requirements=  reqs
-      #Unsuccessfull
-      def test_1()
-        assign_requirement(:req1)  #this test is testing requirement req1
-        assert_equal(3,1+1)
-      end
-      #Unsuccessfull
-      def test_2()
-        assign_requirement(:req1)  #this test is testing requirement req2 without success
-        assert_equal(3,1+1)
-      end
-    end
-    
-    suite = testcase.suite #run tests
-    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
-  end
-  def test_duplicate_test  
-    assert_equal([:req1], @reqs.overview.keys)
-    assert_equal([false], @reqs.overview.values)
-  end
-  def test_overview_txt()
-    @reqs.report_type = :txt  
-     assert_equal(["Requirement req1 was unsuccessfull tested (test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
-  end
-end
-
-class Test_two_tests_for_one_requirement_mixed_result < Test::Unit::TestCase
-  def setup
-    @reqs = reqs = RequirementList.new(:req1)
-    testcase = Class.new(Test::Unit::TestCase) do
-      #Set class name. Normally class name.
-      def self.name;'Test_ReqList';end
-      self.requirements=  reqs
-      #Successfull
-      def test_1()
-        assign_requirement(:req1)  #this test is testing requirement req1
-        assert_equal(2,1+1)
-      end
-      #Unsuccessfull
-      def test_2()
-        assign_requirement(:req1)  #this test is testing requirement req2 without success
-        assert_equal(3,1+1)
-      end
-    end
-    
-    suite = testcase.suite #run tests
-    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
-  end
-  def test_duplicate_test  
-    assert_equal([:req1], @reqs.overview.keys)
-    assert_equal([false], @reqs.overview.values)
-  end
-  def test_overview_txt()
-    @reqs.report_type = :txt  
-     assert_equal(["Requirement req1 was unsuccessfull tested (OK: test_1(Test_ReqList), Failure: test_2(Test_ReqList))",], @reqs.overview)   
-  end
-end
-
+$:.unshift('../lib')
+#~ gem 'test-unit'
+#~ require 'test/unit'
+require 'test4requirements.rb'
+include Test4requirements
+
+RequirementList.report_type_default = nil
+
+#IO to catch stdout in TestRunner
+IO_Catcher = Class.new(IO){ def write(arg);end }.new(2, 'w')  
+
+class Test_RequirementList_Overview_without_test_execution < Test::Unit::TestCase
+  def setup
+    @reqs = RequirementList.new(:reqId, 1,2,3)
+    @testcase = Class.new(Test::Unit::TestCase)
+    @testcase.requirements=  @reqs
+    #~ @testcase.suite() #run tests
+  end
+  
+  def test_overview_default()
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([1,2,3], @reqs.overview.keys)
+    @reqs.overview.each{|key,req| assert_nil(req) }
+  end
+
+  #same as default
+  def test_overview_nil()
+    @reqs.report_type = nil
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([1,2,3], @reqs.overview.keys)
+  end
+
+  def test_overview_txt()
+    @reqs.report_type = :txt
+    assert_kind_of(Array, @reqs.overview)
+    assert_equal(3, @reqs.overview.size)
+    assert_equal(["Requirement 1 was not tested",
+                       "Requirement 2 was not tested",
+                       "Requirement 3 was not tested"], @reqs.overview)
+  end
+
+  def test_overview_unknown()
+    assert_raise(ArgumentError){@reqs.report_type = :unknown}
+    assert_nothing_raised{@reqs.overview}
+    assert_raise(ArgumentError){@reqs.overview(:unknown)}
+  end
+end
+
+
+
+class Test_RequirementList_Overview_with_test_execution < Test::Unit::TestCase
+  def setup
+    @reqs = RequirementList.new(:reqId, :req1,:req2,:req3)
+    @testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      def test_2()
+        assign_requirement(:req2)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    @testcase.requirements=  @reqs
+    
+    suite = @testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  
+  def test_testcase_definition()
+    assert_true(@testcase.instance_methods.include?(:test_1))
+    assert_true(@testcase.instance_methods.include?(:test_2))
+    #~ assert_true(@testcase.respond_to?(:test_1))
+    #~ assert_true(@testcase.respond_to?(:test_2))
+  end
+  
+  def test_overview_default()
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([:req1,:req2,:req3], @reqs.overview.keys)
+    assert_equal([true,false,nil], @reqs.overview.values)
+  end
+
+  #same as default
+  def test_overview_nil()
+    @reqs.report_type = nil
+    assert_kind_of(Hash, @reqs.overview)
+    assert_equal([true,false,nil], @reqs.overview.values)
+  end
+
+  def test_overview_txt()
+    @reqs.report_type = :txt
+    assert_kind_of(Array, @reqs.overview)
+    assert_equal(3, @reqs.overview.size)
+    assert_equal(["Requirement req1 was successfull tested (OK: test_1(Test_ReqList))",
+                       "Requirement req2 was unsuccessfull tested (Failure: test_2(Test_ReqList))",
+                       "Requirement req3 was not tested"
+                    ], @reqs.overview)
+  end
+end
+
+
+
+class Test_two_tests_for_one_requirement_successfull  < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:reqId, :req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(2,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([true], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was successfull tested (OK: test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+class Test_two_tests_for_one_requirement_unsuccessfull < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:reqId, :req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      #Unsuccessfull
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(3,1+1)
+      end
+      #Unsuccessfull
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was unsuccessfull tested (Failure: test_1(Test_ReqList), test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+class Test_two_tests_for_one_requirement_mixed_result < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:reqId, :req1)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      #Successfull
+      def test_1()
+        assign_requirement(:req1)  #this test is testing requirement req1
+        assert_equal(2,1+1)
+      end
+      #Unsuccessfull
+      def test_2()
+        assign_requirement(:req1)  #this test is testing requirement req2 without success
+        assert_equal(3,1+1)
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_duplicate_test  
+    assert_equal([:req1], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req1 was unsuccessfull tested (OK: test_1(Test_ReqList), Failure: test_2(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+
+
+class Test_pend < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:reqId, :req_pend)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      #Successfull
+      def test_pend()
+        assign_requirement(:req_pend)
+        pend("Pending")
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_pend
+    assert_equal([:req_pend], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_pend_overview_txt
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req_pend was unsuccessfull tested (Pending: test_pend(Test_ReqList))",], @reqs.overview)   
+  end
+end
+
+class Test_omit < Test::Unit::TestCase
+  def setup
+    @reqs = reqs = RequirementList.new(:reqId, :req_omit)
+    testcase = Class.new(Test::Unit::TestCase) do
+      #Set class name. Normally class name.
+      def self.name;'Test_ReqList';end
+      self.requirements=  reqs
+      def test_omit()
+        assign_requirement(:req_omit)
+        omit("omiting") if true
+      end
+    end
+    
+    suite = testcase.suite #run tests
+    Test::Unit::UI::Console::TestRunner.run(suite, :output => IO_Catcher)
+  end
+  def test_omit
+    assert_equal([:req_omit], @reqs.overview.keys)
+    assert_equal([false], @reqs.overview.values)
+  end
+  def test_omit_overview_txt()
+    @reqs.report_type = :txt  
+     assert_equal(["Requirement req_omit was unsuccessfull tested (Omission: test_omit(Test_ReqList))"], @reqs.overview)   
+  end
+end
+
+
+