rubyunit 0.3.18 → 0.3.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8358c7108fd24be7c907c1748027db67ff3ea08
-  data.tar.gz: 3eb106f2c6bbcf4d91abcca12cc9704b5b03d465
+  metadata.gz: b42f86c558335da460eae82ff6cd75f73a91524c
+  data.tar.gz: 83c926d309db46f940becd13cdd5d05dc2c53639
 SHA512:
-  metadata.gz: 6bd8fc95b36aa9bd6c116d63f82e77050f0f3f5803b840705be95f21dbe646483bf6134d280c40cb50b3be96278bae7cc3c2bae5f1208a10ad9d7e4c341ff503
-  data.tar.gz: ad1b94006882e02ce1dc9b9d9ba3bbbf486de124f12bbb4ccfbd4a5948e70bf7da168474a84f4447e8739af81f53eb0a49779fdeb2a553afaaac1c6044dc8d50
+  metadata.gz: 96d32102c962c4791dd4e8c4df95b497161c93c7d6741fd962cc99c1075d51902ee025ff8c661ceeb376ce30f05a9f1450b6d2158b112bf6706ab96f643c3ae3
+  data.tar.gz: 8c3a266c53efebc08d7ea4d0389729309719c43682ae327df6574dfb043da12baf4d51d2127e53966102f216cc6db09e845f87dd648b741a8097c92fb67bed2b

data/README.md

@@ -10,6 +10,8 @@ RubyUnit
 * http://rubyunit.github.io/
 * https://github.com/RubyUnit/RubyUnit
 * https://github.com/matthewclower/RubyUnit/wiki
+* https://rubygems.org/gems/rubyunit
+* http://www.rubydoc.info/gems/rubyunit/frames
 
 ### Description
 

data/lib/RubyUnit/Assertions/Comparisons.rb

@@ -158,7 +158,7 @@ module RubyUnit
       #  assertMatch /^Good/, 'Goodbye!', "This will fail"  # => fail
       #
       def assertNotMatch exclusion, value, message = nil
-        __reject (value =~ exclusion), ASSERT_NO_MATCH_ERROR, message, {:exclusion=>exclusion, :value=>value}
+        __reject (value =~ exclusion), ASSERT_NOT_MATCH_ERROR, message, {:exclusion=>exclusion, :value=>value}
       end
 
       #

data/lib/RubyUnit.rb

@@ -13,7 +13,7 @@ module RubyUnit
 
   ##
   # Current RubyUnit version
-  VERSION            = '0.3.18'
+  VERSION            = '0.3.19'
 
   ##
   # Set debug mode

data/tests/Assertions/TC_Collections.rb

@@ -200,14 +200,6 @@ module AssertionsTests
       end
     end
 
-
-
-
-
-
-
-
-
     ##
     # Test assertEmpty
     #

data/tests/Assertions/TC_Comparisons.rb

@@ -1,6 +1,6 @@
 require 'RubyUnit/Assertions'
 
-# Data provider for RubyUnit::TestCase tests
+# Data provider for RubyUnit::Assertions Comparisons tests
 require_relative 'data/Comparisons'
 
 module AssertionsTests
@@ -9,5 +9,205 @@ module AssertionsTests
   #
   class TC_Comparisons < AssertionsTestCase
     include ComparisonsData
+
+    def assertEqualTest expected, value
+      assertEqual expected, value
+    end
+
+    def assertEqualFailTest expected, value
+      rescue_assertion ASSERT_EQUAL_ERROR do
+        assertEqual expected, value
+      end
+    end
+
+    def assertEqualWithMessageTest expected, value, message
+      assertEqual expected, value, message
+    end
+
+    def assertEqualWithMessageFailTest expected, value, message
+      rescue_assertion ASSERT_EQUAL_ERROR, message do
+        assertEqual expected, value, message
+      end
+    end
+
+    def assertNotEqualTest expected, value
+      assertNotEqual expected, value
+    end
+
+    def assertNotEqualFailTest expected, value
+      rescue_assertion ASSERT_NOT_EQUAL_ERROR do
+        assertNotEqual expected, value
+      end
+    end
+
+    def assertNotEqualWithMessageTest expected, value, message
+      assertNotEqual expected, value, message
+    end
+
+    def assertNotEqualWithMessageFailTest expected, value, message
+      rescue_assertion ASSERT_NOT_EQUAL_ERROR, message do
+        assertNotEqual expected, value, message
+      end
+    end
+
+    def assertGreaterThanTest greater, value
+      assertGreaterThan greater, value
+    end
+
+    def assertGreaterThanFailTest greater, value
+      rescue_assertion ASSERT_GREATERTHAN_ERROR do
+        assertGreaterThan greater, value
+      end
+    end
+
+    def assertGreaterThanWithMessageTest greater, value, message
+      assertGreaterThan greater, value, message
+    end
+
+    def assertGreaterThanWithMessageFailTest greater, value, message
+      rescue_assertion ASSERT_GREATERTHAN_ERROR, message do
+        assertGreaterThan greater, value, message
+      end
+    end
+
+    def assertGreaterThanOrEqualTest greater, value
+      assertGreaterThanOrEqual greater, value
+    end
+
+    def assertGreaterThanOrEqualFailTest greater, value
+      rescue_assertion ASSERT_GREATERTHANOREQUAL_ERROR do
+        assertGreaterThanOrEqual greater, value
+      end
+    end
+
+    def assertGreaterThanOrEqualWithMessageTest greater, value, message
+      assertGreaterThanOrEqual greater, value, message
+    end
+
+    def assertGreaterThanOrEqualWithMessageFailTest greater, value, message
+      rescue_assertion ASSERT_GREATERTHANOREQUAL_ERROR, message do
+        assertGreaterThanOrEqual greater, value, message
+      end
+    end
+
+    def assertLessThanTest less, value
+      assertLessThan less, value
+    end
+
+    def assertLessThanFailTest less, value
+      rescue_assertion ASSERT_LESSTHAN_ERROR do
+        assertLessThan less, value
+      end
+    end
+
+    def assertLessThanWithMessageTest less, value, message
+      assertLessThan less, value, message
+    end
+
+    def assertLessThanWithMessageFailTest less, value, message
+      rescue_assertion ASSERT_LESSTHAN_ERROR, message do
+        assertLessThan less, value, message
+      end
+    end
+
+    def assertLessThanOrEqualTest less, value
+      assertLessThanOrEqual less, value
+    end
+
+    def assertLessThanOrEqualFailTest less, value
+      rescue_assertion ASSERT_LESSTHANOREQUAL_ERROR do
+        assertLessThanOrEqual less, value
+      end
+    end
+
+    def assertLessThanOrEqualWithMessageTest less, value, message
+      assertLessThanOrEqual less, value, message
+    end
+
+    def assertLessThanOrEqualWithMessageFailTest less, value, message
+      rescue_assertion ASSERT_LESSTHANOREQUAL_ERROR, message do
+        assertLessThanOrEqual less, value, message
+      end
+    end
+
+    def assertMatchTest pattern, value
+      assertMatch pattern, value
+    end
+
+    def assertMatchFailTest pattern, value
+      rescue_assertion ASSERT_MATCH_ERROR do
+        assertMatch pattern, value
+      end
+    end
+
+    def assertMatchWithMessageTest pattern, value, message
+      assertMatch pattern, value, message
+    end
+
+    def assertMatchWithMessageFailTest pattern, value, message
+      rescue_assertion ASSERT_MATCH_ERROR, message do
+        assertMatch pattern, value, message
+      end
+    end
+
+    def assertNotMatchTest pattern, value
+      assertNotMatch pattern, value
+    end
+
+    def assertNotMatchFailTest pattern, value
+      rescue_assertion ASSERT_NOT_MATCH_ERROR do
+        assertNotMatch pattern, value
+      end
+    end
+
+    def assertNotMatchWithMessageTest pattern, value, message
+      assertNotMatch pattern, value, message
+    end
+
+    def assertNotMatchWithMessageFailTest pattern, value, message
+      rescue_assertion ASSERT_NOT_MATCH_ERROR, message do
+        assertNotMatch pattern, value, message
+      end
+    end
+
+    def assertSameTest object
+      assertSame object, object
+    end
+
+    def assertSameFailTest expected, object
+      rescue_assertion ASSERT_SAME_ERROR do
+        assertSame expected, object
+      end
+    end
+
+    def assertSameWithMessageTest object, message
+      assertSame object, object, message
+    end
+
+    def assertSameWithMessageFailTest expected, object, message
+      rescue_assertion ASSERT_SAME_ERROR, message do
+        assertSame expected, object, message
+      end
+    end
+
+    def assertNotSameTest expected, object
+      assertNotSame expected, object
+    end
+
+    def assertNotSameFailTest object
+      rescue_assertion ASSERT_NOT_SAME_ERROR do
+        assertNotSame object, object
+      end
+    end
+
+    def assertNotSameWithMessageTest expected, object, message
+      assertNotSame expected, object, message
+    end
+
+    def assertNotSameWithMessageFailTest object, message
+      rescue_assertion ASSERT_NOT_SAME_ERROR, message do
+        assertNotSame object, object, message
+      end
+    end
   end
 end

data/tests/Assertions/data/Comparisons.rb

@@ -1,7 +1,256 @@
+require_relative 'ObjectTypes'
+
 module AssertionsTests
   #
   # Data provider for RubyUnit::Assertions Comparisons assertions
   #
   module ComparisonsData
+    include ObjectTypes
+
+    def double data
+      data.each do |params|
+        params << params.first
+      end
+      data
+    end
+
+    def assertEqualData
+      data = non_classes + classObjects
+      double data
+    end
+    alias_method :assertNotEqualFailData, :assertEqualData
+
+    def assertEqualFailData
+      assertLessThanData + assertGreaterThanData
+    end
+    alias_method :assertNotEqualData, :assertEqualFailData
+    
+    def assertEqualWithMessageData
+      add_parameter assertEqualData
+    end
+    alias_method :assertNotEqualWithMessageFailData, :assertEqualWithMessageData
+
+    def assertEqualWithMessageFailData
+      add_parameter assertEqualFailData
+    end
+    alias_method :assertNotEqualWithMessageData, :assertEqualWithMessageFailData
+
+    def equalComparisonObjects
+      data =
+      fixnumObjects   +
+      bignumObjects   +
+      floatObjects    +
+      rationalObjects +
+      timeObjects
+
+      double data
+    end
+
+    def assertGreaterThanData
+      [
+        # Fixnum
+        [-42, -420],
+        [ 42,  -42],
+        [ 42,    0],
+        # Bignum
+        [-42000000000000000, -420000000000000000],
+        [ 42000000000000000,  -42000000000000000],
+        [ 42000000000000000,                   0],
+        # Float
+        [-4.2, -42.0],
+        [ 4.2,  -4.2],
+        [ 4.2,   0.0],
+        # Rational
+        [Rational(-4,2), Rational(-42,4)],
+        [ Rational(4,2),  Rational(-4,2)],
+        [ Rational(4,2),   Rational(0,1)],
+        # Time
+        [        Time.new(2002), Time.new(2001, 12, 31)],
+        [    Time.new(2002, 10),      Time.new(2002, 9)],
+        [Time.new(2002, 10, 31),         Time.new(2001)],
+      ]
+    end
+
+    def assertGreaterThanFailData
+      assertLessThanData + equalComparisonObjects
+    end
+
+    def assertGreaterThanWithMessageData
+      add_parameter assertGreaterThanData
+    end
+
+    def assertGreaterThanWithMessageFailData
+      add_parameter assertGreaterThanFailData
+    end
+
+    def assertGreaterThanOrEqualData
+      assertGreaterThanData + equalComparisonObjects
+    end
+
+    def assertGreaterThanOrEqualFailData
+      assertLessThanData
+    end
+
+    def assertGreaterThanOrEqualWithMessageData
+      add_parameter assertGreaterThanOrEqualData
+    end
+
+    def assertGreaterThanOrEqualWithMessageFailData
+      add_parameter assertGreaterThanOrEqualFailData
+    end
+
+    def assertLessThanData
+      [
+        # Fixnum
+        [-420, -42],
+        [ -42,  42],
+        [   0,  42],
+        # Bignum
+        [-420000000000000000, -42000000000000000],
+        [ -42000000000000000,  42000000000000000],
+        [                  0,  42000000000000000],
+        # Float
+        [-42.0, -4.2],
+        [ -4.2,  4.2],
+        [  0.0,  4.2],
+        # Rational
+        [Rational(-42,4), Rational(-4,2)],
+        [ Rational(-4,2),  Rational(4,2)],
+        [  Rational(0,1),  Rational(4,2)],
+        # Time
+        [Time.new(2001, 12, 31),         Time.new(2002)],
+        [     Time.new(2002, 9),     Time.new(2002, 10)],
+        [        Time.new(2001), Time.new(2002, 10, 31)],
+      ]
+    end
+
+    def assertLessThanFailData
+      assertGreaterThanData + equalComparisonObjects
+    end
+
+    def assertLessThanWithMessageData
+      add_parameter assertLessThanData
+    end
+
+    def assertLessThanWithMessageFailData
+      add_parameter assertLessThanFailData
+    end
+
+    def assertLessThanOrEqualData
+      assertLessThanData + equalComparisonObjects
+    end
+
+    def assertLessThanOrEqualFailData
+      assertGreaterThanData
+    end
+
+    def assertLessThanOrEqualWithMessageData
+      add_parameter assertLessThanOrEqualData
+    end
+
+    def assertLessThanOrEqualWithMessageFailData
+      add_parameter assertLessThanOrEqualFailData
+    end
+
+    def assertMatchData
+      [
+        [             /Start/, 'Start middle end'],
+        [            /^Start/, 'Start middle end'],
+        [            /middle/, 'Start middle end'],
+        [               /end/, 'Start middle end'],
+        [              /end$/, 'Start middle end'],
+        [      /Start middle/, 'Start middle end'],
+        [     /^Start middle/, 'Start middle end'],
+        [        /middle end/, 'Start middle end'],
+        [       /middle end$/, 'Start middle end'],
+        [  /Start middle end/, 'Start middle end'],
+        [ /^Start middle end/, 'Start middle end'],
+        [/^Start middle end$/, 'Start middle end'],
+      ]
+    end
+    alias_method :assertNotMatchFailData, :assertMatchData
+
+    def assertMatchFailData
+      [
+        [            /Start$/, 'Start middle end'],
+        [           /^Start$/, 'Start middle end'],
+        [           /^middle/, 'Start middle end'],
+        [           /$middle/, 'Start middle end'],
+        [          /^middle$/, 'Start middle end'],
+        [              /^end/, 'Start middle end'],
+        [             /^end$/, 'Start middle end'],
+        [    /^Start middle$/, 'Start middle end'],
+        [     /Start middle$/, 'Start middle end'],
+        [      /^middle end$/, 'Start middle end'],
+        [       /^middle end/, 'Start middle end'],
+      ]
+    end
+    alias_method :assertNotMatchData, :assertMatchFailData
+
+    def assertMatchWithMessageData
+      add_parameter assertMatchData
+    end
+    alias_method :assertNotMatchWithMessageFailData, :assertMatchWithMessageData
+
+    def assertMatchWithMessageFailData
+      add_parameter assertMatchFailData
+    end
+    alias_method :assertNotMatchWithMessageData, :assertMatchWithMessageFailData
+
+    def assertSameData
+      non_classes + classObjects
+    end
+    alias_method :assertNotSameFailData, :assertSameData
+
+    def assertSameFailData
+      data =
+      timeObjects     +
+      stringObjects   +
+      rangeObjects    +
+      arrayObjects    +
+      hashObjects
+
+      regexpObjects   +
+
+
+      data.each do |param|
+        param << param.first.clone
+      end
+      data + [
+        # Specific
+        [  nil,  true],
+        [ true, false],
+        [false,   nil],
+        # Numbers
+        [               42, 42000000000000000],
+        [42000000000000000,               4.2],
+        [              4.2,   Rational(21, 5)],
+        # Complex
+        [         Complex(1),       Complex(2, 3)],
+        [      Complex(2, 3), Complex.polar(2, 3)],
+        [Complex.polar(2, 3),        Complex(0.3)],
+        [       Complex(0.3), Complex('0.3-0.5i')],
+        [Complex('0.3-0.5i'), Complex('2/3+3/4i')],
+        [Complex('2/3+3/4i'),      Complex('1@2')],
+        [     Complex('1@2'),          Complex(1)],
+        # Regexp
+        [                          //,                   /Regexp 1/],
+        [                  /Regexp 1/,             /\AStart Regexp/],
+        [            /\AStart Regexp/,                /END regexp$/],
+        [               /END regexp$/, /^#{'interpolated'} REGEXP$/],
+        [/^#{'interpolated'} REGEXP$/,                           //],
+      ]
+    end
+    alias_method :assertNotSameData, :assertSameFailData
+    
+    def assertSameWithMessageData
+      add_parameter assertSameData
+    end
+    alias_method :assertNotSameWithMessageFailData, :assertSameWithMessageData
+
+    def assertSameWithMessageFailData
+      add_parameter assertSameFailData
+    end
+    alias_method :assertNotSameWithMessageData, :assertSameWithMessageFailData
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyunit
 version: !ruby/object:Gem::Version
-  version: 0.3.18
+  version: 0.3.19
 platform: ruby
 authors:
 - Matthew Clower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake