rubyunit 0.2.14 → 0.3.15

data/tests/Assertions/data/Basic.rb

@@ -0,0 +1,90 @@
+require_relative 'ObjectTypes'
+
+module AssertionsTests
+  #
+  # Data provider for RubyUnit::Assertions Basic assertions
+  #
+  module BasicData
+    include ObjectTypes
+
+    def failWithMessageData
+      AssertionsTests::MESSAGES
+    end
+
+    def failWithDataData
+      add_parameter AssertionsTests::MESSAGES, hashObjects
+    end
+
+    def assertData
+      trueObjects + basicObjects
+    end
+    alias_method :assertNotFailData, :assertData
+
+    def assertWithMessageData
+      add_parameter assertData
+    end
+    alias_method :assertNotFailWithMessageData, :assertWithMessageData
+
+    def assertFailData
+      falseObjects + nilObjects
+    end
+    alias_method :assertNotData, :assertFailData
+
+    def assertFailWithMessageData
+      add_parameter assertFailData
+    end
+    alias_method :assertNotWithMessageData, :assertFailWithMessageData
+
+    def assertTrueData
+      trueObjects
+    end
+
+    def assertTrueWithMessageData
+      add_parameter assertTrueData
+    end
+
+    def assertTrueFailData
+      falseObjects + nilObjects + basicObjects
+    end
+
+    def assertTrueFailWithMessageData
+      add_parameter assertTrueFailData
+    end
+
+    def assertFalseData
+      falseObjects
+    end
+ 
+    def assertFalseWithMessageData
+      add_parameter assertFalseData
+    end
+
+    def assertFalseFailData
+      trueObjects + basicObjects + nilObjects
+    end
+
+    def assertFalseFailWithMessageData
+      add_parameter assertFalseFailData
+    end
+
+    def assertNilData
+      nilObjects
+    end
+    alias_method :assertNotNilFailData, :assertNilData
+
+    def assertNilWithMessageData
+      add_parameter assertNilData
+    end
+    alias_method :assertNotNilFailWithMessageData, :assertNilWithMessageData
+
+    def assertNilFailData
+      trueObjects + basicObjects + falseObjects
+    end
+    alias_method :assertNotNilData, :assertNilFailData
+
+    def assertNilFailWithMessageData
+      add_parameter assertNilFailData
+    end
+    alias_method :assertNotNilWithMessageData, :assertNilFailWithMessageData
+  end
+end

data/tests/Assertions/data/Class.rb

@@ -0,0 +1,54 @@
+require_relative 'ObjectTypes'
+
+module AssertionsTests
+  ##
+  # Data provider for RubyUnit::Assertions Class assertions
+  #
+  module ClassData
+    include ObjectTypes
+
+    def assertKindOfData
+      data  = add_parameter [[Class]], classObjects
+      data += add_parameter [[NilClass]], nilObjects
+      data += add_parameter [[TrueClass]], trueObjects
+      data += add_parameter [[FalseClass]], falseObjects
+      data += add_parameter [[Numeric], [Integer], [Fixnum]], fixnumObjects
+      data += add_parameter [[Numeric], [Integer], [Bignum]], bignumObjects
+      data += add_parameter [[Numeric], [Float]], floatObjects
+      data += add_parameter [[Numeric], [Rational]], rationalObjects
+      data += add_parameter [[Numeric], [Complex]], complexObjects
+      data += add_parameter [[Time]], timeObjects
+      data += add_parameter [[String]], stringObjects
+      data += add_parameter [[Range]], rangeObjects
+      data += add_parameter [[Regexp]], regexpObjects
+      data += add_parameter [[Array]], arrayObjects
+      data += add_parameter [[Hash]], hashObjects
+    end
+
+    def assertKindOfFailData
+      data  = add_parameter classes_exclude([Class]), classObjects
+      data += add_parameter classes_exclude([NilClass]), nilObjects
+      data += add_parameter classes_exclude([TrueClass]), trueObjects
+      data += add_parameter classes_exclude([FalseClass]), falseObjects
+      data += add_parameter classes_exclude([Numeric, Integer, Fixnum]), fixnumObjects
+      data += add_parameter classes_exclude([Numeric, Integer, Bignum]), bignumObjects
+      data += add_parameter classes_exclude([Numeric, Float]), floatObjects
+      data += add_parameter classes_exclude([Numeric, Rational]), rationalObjects
+      data += add_parameter classes_exclude([Numeric, Complex]), complexObjects
+      data += add_parameter classes_exclude([Time]), timeObjects
+      data += add_parameter classes_exclude([String]), stringObjects
+      data += add_parameter classes_exclude([Range]), rangeObjects
+      data += add_parameter classes_exclude([Regexp]), regexpObjects
+      data += add_parameter classes_exclude([Array]), arrayObjects
+      data += add_parameter classes_exclude([Hash]), hashObjects
+    end
+
+    def assertKindOfWithMessageData
+      add_parameter assertKindOfData
+    end
+
+    def assertKindOfWithMessageFailData
+      add_parameter assertKindOfFailData
+    end
+  end
+end

data/tests/Assertions/data/Comparison.rb

@@ -0,0 +1,7 @@
+module AssertionsTests
+  #
+  # Data provider for RubyUnit::Assertions Comparison assertions
+  #
+  module ComparisonData
+  end
+end

data/tests/Assertions/data/ObjectTypes.rb

@@ -0,0 +1,174 @@
+module AssertionsTests
+  module ObjectTypes
+    def basicObjects
+      fixnumObjects   +
+      bignumObjects   +
+      floatObjects    +
+      rationalObjects +
+      complexObjects  +
+      timeObjects     +
+      stringObjects   +
+      rangeObjects    +
+      regexpObjects   +
+      arrayObjects    +
+      hashObjects
+    end
+
+    def classes_exclude klasses
+      classes = classObjects
+      klasses.each do |klass|
+        classes -= [[klass]]
+      end
+      classes
+    end
+
+    def classObjects
+      [
+        [  NilClass],
+        [ TrueClass],
+        [FalseClass],
+        [   Numeric],
+        [   Integer],
+        [    Fixnum],
+        [    Bignum],
+        [     Float],
+        [  Rational],
+        [   Complex],
+        [      Time],
+        [    String],
+        [     Range],
+        [     Array],
+        [      Hash],
+      ]
+    end
+
+    def nilObjects
+      [
+        [nil]
+      ]
+    end
+
+    def trueObjects
+      [
+        [true]
+      ]
+    end
+
+    def falseObjects
+      [
+        [false]
+      ]
+    end
+
+    def fixnumObjects
+      [
+        [-42],
+        [ -1],
+        [  0],
+        [  1],
+        [ 42],
+      ]
+    end
+
+    def bignumObjects
+      [
+        [-42000000000000000000],
+        [ 42000000000000000000],
+      ]
+    end
+
+    def floatObjects
+      [
+        [  -4.2],
+        [-0.042],
+        [   0.0],
+        [ 0.042],
+        [   4.2],
+      ]
+    end
+
+    def rationalObjects
+      [
+        [    Rational(1)],
+        [ Rational(2, 3)],
+        [Rational(4, -6)],
+        [  Rational(0.3)],
+        [Rational('0.3')],
+        [Rational('2/3')],
+      ]
+    end
+
+    def complexObjects
+      [
+        [         Complex(1)],
+        [      Complex(2, 3)],
+        [Complex.polar(2, 3)],
+        [       Complex(0.3)],
+        [Complex('0.3-0.5i')],
+        [Complex('2/3+3/4i')],
+        [     Complex('1@2')],
+      ]
+    end
+
+    def timeObjects
+      [
+        [                           Time.new(2002)],
+        [                       Time.new(2002, 10)],
+        [                   Time.new(2002, 10, 31)],
+        [Time.new(2002, 10, 31, 2, 2, 2, "+02:00")],
+        [                       Time.at(628232400)],
+      ]
+    end
+
+    def stringObjects
+      [
+        [                   ''],
+        [         'string one'],
+        [           "STRING 2"],
+        [       "String #{42}"],
+        [    'Two Word string'],
+        ["Three\nLINE\nString"],
+      ]
+    end
+
+    def rangeObjects
+      [
+        [   (-1..-5)],
+        [   (-5..-1)],
+        [ ('a'..'e')],
+        [('a'...'e')],
+      ]
+    end
+
+    def regexpObjects
+      [
+        [                          //],
+        [                  /Regexp 1/],
+        [            /\AStart Regexp/],
+        [               /END regexp$/],
+        [/^#{'interpolated'} REGEXP$/],
+      ]
+    end
+
+    def arrayObjects
+      [
+        [                    []],
+        [fixnumObjects.flatten],
+        [ bignumObjects.flatten],
+        [  floatObjects.flatten],
+        [  classObjects.flatten],
+        [ stringObjects.flatten],
+        [ regexpObjects.flatten],
+      ]
+    end
+
+    def hashObjects
+      [
+        [                                        {}],
+        [                        {:regex=>/Regexp/}],
+        [              {:string=>'string',:int=>42}],
+        [{:class=>Class,:int=>42,:string=>'string'}],
+      ]
+    end
+  end
+end

data/tests/IncompleteTest/TC_IncompleteTest.rb

@@ -0,0 +1,15 @@
+require 'RubyUnit/IncompleteTest'
+
+module IncompleteTestTests
+  #
+  # Test Case for RubyUnit::IncompleteTest
+  #
+  class TC_IncompleteTest < RubyUnit::TestCase
+    #
+    # Validate that RubyUnit::IncompleteTest is an Exception
+    #
+    def isExceptionTest
+      assertDescendent Exception, RubyUnit::IncompleteTest, 'IncompleteTest MUST be an Exception'
+    end
+  end
+end

data/tests/RubyUnit/TC_RubyUnit.rb

@@ -1,15 +1,45 @@
 require 'RubyUnit'
 
+# Data provider for RubyUnit::GemInfo tests
+require_relative 'data/RubyUnit'
+
 module RubyUnitTests
   #
   # Test Case for the RubyUnit module
   #
   class TC_RubyUnit < RubyUnit::TestCase
+    include RubyUnitTestsData
+
     #
     # Verify that the VERSION constant is defined in the RubyUnit module
     #
     def versionDefinedTest
       assertConstDefined RubyUnit, 'VERSION', 'Version must be defined in RubyUnit::VERSION'
     end
+
+    #
+    # Test debug mode
+    #
+    def debugModeTest
+      old_mode = RubyUnit.debug
+      RubyUnit.debug = true
+      assertEqual true, RubyUnit.debug, 'Debug mode should be true'
+      RubyUnit.debug = false
+      assertEqual false, RubyUnit.debug, 'Debug mode should be false'
+      RubyUnit.debug = old_mode
+    end
+
+    #
+    # Test that debug mode doesn't accept non-Boolean
+    #
+    def invalidDebugModeTest mode
+      old_mode = RubyUnit.debug
+      assertRaiseExpected ArgumentError, RubyUnit::INVALID_DEBUG_MODE, RubyUnit::INVALID_DEBUG_MODE do
+        RubyUnit.debug = mode
+      end
+      assertEqual old_mode, RubyUnit.debug, 'Invalid debug mode should not change debug mode'
+    ensure
+      RubyUnit.debug = old_mode
+    end
   end
 end

data/tests/RubyUnit/data/RubyUnit.rb

@@ -0,0 +1,16 @@
+module RubyUnitTests
+  #
+  # Data provider for RubyUnit::GemInfo module Test Case
+  #
+  module RubyUnitTestsData
+    def invalidDebugModeData
+      [
+        [      42],
+        [     nil],
+        ['String'],
+        [   Class],
+        [/Regexp/],
+      ]
+    end
+  end
+end

data/tests/Runner/TC_Runner.rb

@@ -0,0 +1,9 @@
+require 'RubyUnit/Runner'
+
+module RunnerTests
+  #
+  # Test Case for the RubyUnit::Runner
+  #
+  class TEST_Runner < RubyUnit::TestCase
+  end
+end

data/tests/SkippedTest/TC_SkippedTest.rb

@@ -0,0 +1,15 @@
+require 'RubyUnit/SkippedTest'
+
+module SkippedTestTests
+  #
+  # Test Case for RubyUnit::SkippedTest
+  #
+  class TC_SkippedTest < RubyUnit::TestCase
+    #
+    # Validate that RubyUnit::SkippedTest is an Exception
+    #
+    def isExceptionTest
+      assertDescendent Exception, RubyUnit::SkippedTest, 'SkippedTest MUST be an Exception!'
+    end
+  end
+end

data/tests/TS_AssertionFailure.rb

@@ -3,5 +3,7 @@
 require 'RubyUnit'
 
 # Test Cases
-require_relative 'AssertionFailure/TC_Class'
-require_relative 'AssertionFailure/TC_Instance'
+Dir["#{File.dirname(__FILE__)}/AssertionFailure/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_AssertionMessage.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/AssertionMessage/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_Assertions.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+module AssertionsTests
+  ##
+  # Messages to be used in the tests
+  #
+  MESSAGES = [
+    [                                  ''],
+    [ 'AssertionsTests Assertion Message'],
+    ["#{'iterpolated'} Assertion Message"],
+  ]
+
+  class AssertionsTestCase < RubyUnit::TestCase
+    include RubyUnit::AssertionMessage
+
+    ##
+    # Keep count of assertions
+    @assertions
+
+    ##
+    # Setup tests
+    #
+    def setup
+      @assertions = RubyUnit::TestCase.assertions
+    end
+
+    ##
+    # Teardown tests
+    # * All tests on Assertions should add to the assertion count
+    #
+    def teardown
+      assertGreaterThan @@assertions, @assertions, 'Test should make assertions'
+    end
+
+    ##
+    # Wrapper to rescue assertions
+    #
+    def rescue_assertion pattern = '', message = nil, data = {}, &block
+      failure = assertRaiseExpected RubyUnit::AssertionFailure, pattern, message do
+        yield
+      end
+      info = failure.info
+      assertMatch /#{message}/, info, 'Assertion failure message mismatch'
+      data.each do |key, value|
+        assertMatch [/#{key}/, /#{value.inspect}/], info, 'Expected failure info not found'
+      end
+    end
+
+    ##
+    # Add parameter on the end of each param list
+    def add_parameter array, params = MESSAGES
+      a = []
+      params.each do |param|
+        a = a + array.collect {|element| element.clone + param}
+      end
+      a
+    end
+  end
+end
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/Assertions/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_IncompleteTest.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/IncompleteTest/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_RubyUnit.rb

@@ -3,5 +3,7 @@
 require 'RubyUnit'
 
 # Test Cases
-require_relative 'RubyUnit/TC_RubyUnit'
-require_relative 'RubyUnit/TC_GemInfo'
+Dir["#{File.dirname(__FILE__)}/RubyUnit/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_Runner.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/Runner/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_SkippedTest.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/SkippedTest/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TS_TestCase.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'RubyUnit'
+
+# Test Cases
+Dir["#{File.dirname(__FILE__)}/TestCase/TC_*.rb"].each do |test_case|
+  puts "Adding Test Case #{test_case}" if RubyUnit.debug
+  require test_case
+end

data/tests/TestCase/TC_TestCase.rb

@@ -0,0 +1,120 @@
+require 'RubyUnit/TestCase'
+
+# Data provider for RubyUnit::TestCase tests
+require_relative 'data/TestCase'
+
+module TestCaseTests
+  #
+  # Test Case for the RubyUnit::TestCase
+  #
+  class TC_TestCase < RubyUnit::TestCase
+    include TestCaseTestsData
+    @setup
+    @teardown
+
+    #
+    # Initialize setup and teardown before each test
+    #
+    def initialize
+      super
+      @setup    = false
+      @teardown = false
+    end
+
+    class << self
+      # Track whether class setup has been run
+      @@setup    = false
+      # Track whether class teardown has been run
+      @@teardown = false
+
+      #
+      # Setup before class
+      #
+      def setup
+        @@setup = true
+      end
+
+      #
+      # Teardown after class
+      #
+      def teardown
+        @@teardown = true
+      end
+    end
+
+    #
+    # Setup before test
+    # * self.setup has been run before test begins
+    # * self.teardown has not been run before test begins
+    # * setup is only run once
+    #
+    def setup
+      assert @@setup, 'setup class method MUST be run before tests begin.'
+      assertNot @@teardown, 'teardown class should NOT be run before testing'
+      assertNot @setup, 'setup instance method should only be run once'
+      @setup = true
+    end
+
+    #
+    # Teardown after test
+    #
+    def teardown
+      @teardown = true
+    end
+
+    #
+    # Test that descendents method includes this class
+    #
+    def descendentsTest
+      assertInclude RubyUnit::TestCase.descendents, self.class, 'Should be a descendent of RubyUnit::TestCase'
+    end
+
+    #
+    # Test that the correct class methods are defined
+    #
+    def classMethodTest method
+      assertClassMethod RubyUnit::TestCase, method, 'RubyUnit::TestCase missing class method'
+    end
+
+    #
+    # Test that the correct instance methods are defined
+    #
+    def instanceMethodTest method
+      assertInstanceMethod RubyUnit::TestCase, method, 'TestCase object missing instance method'
+    end
+
+    #
+    # Test that setup is run before test
+    #
+    def setupBeforeTestTest
+      assert @setup, 'setup instance method MUST be run before test'
+    end
+
+    #
+    # Test that teardown is not run before test
+    #
+    def noTeardownBeforeTestTest
+      assertNot @teardown, 'teardown instance method should NOT be run before test'
+    end
+
+    #
+    # Test that markSkipped raises proper exception
+    #
+    def markSkippedTest
+      message = 'markSkipped should raise RubyUnit::SkippedTest'
+      assertRaiseExpected RubyUnit::SkippedTest, message, message do
+        markSkipped message
+      end
+    end
+
+    #
+    # Test that markIncomplete raises proper exception
+    #
+    def markIncompleteTest
+      message = 'markIncomplete should raise RubyUnit::IncompleteTest'
+      assertRaiseExpected RubyUnit::IncompleteTest, message, message do
+        markIncomplete message
+      end
+    end
+  end
+end