assay-testunit 0.1.0

data/.ruby

@@ -0,0 +1,52 @@
+---
+source:
+- meta
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: assay
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/assay-testunit.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/assay-testunit
+  docs: http://rubydoc.info/gems/assay-testunit
+  code: http://github.com/rubyworks/assay-testunit
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-01-18'
+summary: TestUnit on Assay
+title: Assay TestUnit
+version: 0.1.0
+name: assay-testunit
+description: ! 'Assay TestUnit defines a set of TestUnit-compatible assertion methods
+  which
+
+  depend on Assay''s assertion classes. This allows developers to change
+
+  test frameworks without having to change a slew of previously
+
+  defined assertions.'
+organization: Rubyworks
+date: '2012-01-25'

data/.yardopts

@@ -0,0 +1,7 @@
+--title "Assay TestUnit"
+--readme README.rdoc
+--protected
+--private
+lib
+-
+[A-Z]*.*

data/COPYING.rdoc

@@ -0,0 +1,34 @@
+= COPYRIGHT
+
+== NOTICES
+
+=== Assay TestUnit
+
+Copyright:: (c) 2012 Rubyworks
+License:: BSD-2-Clause
+Website:: http://rubyworks.github.com/assay-testunit
+
+== LICENSES
+
+=== BSD-2-Clause License
+ 
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+     1. Redistributions of source code must retain the above copyright notice,
+        this list of conditions and the following disclaimer.
+
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+  COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/DEMOS.rdoc

@@ -0,0 +1,267 @@
+# Assertion Methods
+
+To use the assertion methods, first require the library.
+
+  require 'assay/testunit'
+
+Then include them into your test scope.
+
+  include ::Assay::Assertions
+
+## assert_equal
+
+  assert_equal(1,1)
+
+  expect ::EqualAssay do
+    assert_equal(1,2)
+  end
+
+  assert_not_equal(1,2)
+
+## assert_true
+
+  assert_true(true)
+
+  expect ::TrueAssay do
+    assert_true(false)
+  end
+
+  assert_not_true(false)
+  assert_not_true(nil)
+
+## assert_false
+
+  assert_false(false)
+
+  expect ::FalseAssay do
+    assert_false(true)
+  end
+
+  assert_not_false(true)
+  assert_not_false(nil)
+
+## assert_nil
+
+  assert_nil(nil)
+
+  expect ::NilAssay do
+    assert_nil(true)
+  end
+
+  assert_not_nil(true)
+  assert_not_nil(false)
+
+## assert_in_delta
+
+  assert_in_delta(1, 1.5, 2)
+
+  expect ::WithinAssay do
+    assert_in_delta(1, 2.5, 1)
+  end
+
+  assert_not_in_delta(1, 2, 0.5)
+
+## assert_in_epsilon
+
+  assert_in_epsilon(1, 1.5, 2)
+  assert_in_epsilon(0, 1.5, 2)
+
+  expect ::WithinAssay do
+    assert_in_epsilon(1, 2.5, 1)
+  end
+
+  assert_not_in_epsilon(1, 2.5, 1)
+  assert_not_in_epsilon(0, 2.5, 1)
+
+## assert_match
+
+  assert_match(/a/, "abc")
+
+  expect ::MatchAssay do
+    assert_match(/x/, "abc")
+  end
+
+  assert_not_match(/a/, "bcd")
+
+## assert_no_match
+
+  assert_no_match(/a/, "bcd")
+
+  expect ::NoMatchAssay do
+    assert_no_match(/a/, "abc")
+  end
+
+## assert_empty
+
+  assert_empty([])
+
+  expect ::EmptyAssay do
+    assert_empty([1,2,3])
+  end
+
+  assert_not_empty([1,2,3])
+
+## assert_include
+
+  assert_includes([1,2,3], 1)
+
+  expect ::IncludeAssay do
+    assert_includes([1,2,3], 4)
+  end
+
+  assert_not_includes([1,2,3], 4)
+
+## assert_same
+
+  assert_same(:a, :a)
+
+  expect ::IdentityAssay do
+    assert_same("a", "a")
+  end
+
+  assert_not_same(:a, :b)
+
+## assert_instance_of
+
+  assert_instance_of(Fixnum, 1)
+
+  expect ::InstanceAssay do
+    assert_instance_of(String, 1)
+  end
+
+  assert_not_instance_of(String, 1)
+
+## assert_kind_of
+
+  assert_kind_of(Integer, 1)
+
+  expect ::KindAssay do
+    assert_kind_of(String, 1)
+  end
+
+  assert_not_kind_of(String, 1)
+
+## assert_raise
+
+  assert_raise(ArgumentError){ raise ArgumentError }
+
+  expect ::RaiseAssay do
+    assert_raise(ArgumentError){ raise TypeError }
+  end
+
+  assert_not_raised(ArgumentError){ raise TypeError }
+
+## assert_raise_kind_of
+
+  assert_raise_kind_of(StandardError){ raise }
+
+  expect ::RescueAssay do
+    assert_raise_kind_of(ArgumentError){ raise TypeError }
+  end
+
+  assert_raise_kind_of(Exception){ raise }
+
+## assert_nothing_raised
+
+  assert_nothing_raised{ true }
+  assert_nothing_raised{ nil }
+
+  expect ::RescueAssay do
+    assert_nothing_raised{ raise }
+  end
+
+## assert_respond_to
+
+  assert_respond_to("string", :upcase)
+
+  expect ::RespondAssay do
+    assert_respond_to("string", :not_a_method)
+  end
+
+  assert_not_respond_to("string", :not_a_method)
+
+## assert_block
+
+  assert_block{ :ok }
+
+  expect ::ExecutionAssay do
+    assert_block{ raise }
+  end
+
+## assert_throw
+
+  assert_throw(:foo){ throw :foo }
+
+  expect ::ThrowAssay do
+    assert_throw(:foo){ throw :bar }
+  end
+
+  assert_not_thrown(:foo){ throw :bar }
+
+## assert_nothing_thrown
+
+  assert_nothing_thrown{ nil }
+
+  expect ::ThrowAssay do
+    assert_nothing_thrown{ throw :bar }
+  end
+
+## assert_compare
+
+  assert_compare(1, :<,  2)
+  assert_compare(2, :>,  1)
+  assert_compare(1, :<=, 1)
+  assert_compare(1, :>=, 1)
+  assert_compare(1, :<=, 2)
+  assert_compare(2, :>=, 1)
+  assert_compare(1, :==, 1)
+
+  expect ArgumentError do
+    assert_compare(1, :<=>, 1)
+  end
+
+## assert_operator
+
+  assert_operator([], :<<, 1)
+
+## assert_predicate
+
+  assert_predicate(10, :even?)
+
+  assert_not_predicate(10, :odd?)
+
+## assert_path_exist
+
+  assert_path_exist(__FILE__)
+
+  assert_path_not_exist(__FILE__ + '.foobar')
+
+## assert_boolean
+
+  assert_boolean(true)
+  assert_boolean(false)
+
+  assert_not_boolean(nil)
+
+## assert_alike
+
+  assert_alike(1,1)
+  assert_alike(1,1.0)
+
+  expect ::LikeAssay do
+    assert_alike(1,"1")
+  end
+
+  assert_not_alike(1,"1")
+
+## assert_equivalent
+
+  assert_equivalent(1, 1)
+
+  expect ::EqualityAssay do
+    assert_equivalent(1, 1.0)
+  end
+
+  assert_not_equivalent(1, 1.0)
+
+

data/HISTORY.rdoc

@@ -0,0 +1,10 @@
+= HISTORY
+
+== 0.1.0 | 2012-01-25
+
+This is the initial release of Assay TestUnit.
+
+Changes:
+
+* Happy Birthday!
+

data/README.rdoc

@@ -0,0 +1,70 @@
+= Assay TestUnit
+
+{Homepage}[http://rubyworks.github.com/assay-testunit] /
+{Report Issue}[http://github.com/rubyworks/assay-testunit/issues] /
+{Source Code}[http://github.com/rubyworks/assay-testunit] /
+{Mailing List}[http://groups.google.com/group/rubyworks-mailinglist]
+
+
+== DESCRIPTION
+
+Assay TestUnit is a compatibility layer for using TestUnit's assertion
+notation with the {Assay}[http://rubyworks.github.com/assay]
+assertions framework.
+
+Assay TestUnit defines a set of TestUnit-compatible assertion methods
+which depend on Assay's assertion classes. This allows developers to
+change test frameworks without having to change a slew of previously
+defined assertions calls.
+
+Assay defines assertions in the same way that Ruby defines exceptions.
+An assertion is nothing more that an extended Exception subclass.
+Assay provides a complete set of these assertion classes for all
+common assertion needs. See {Assay}[http://rubyworks.github.com/assay]
+project for more information on this library.
+
+
+== SYNOPSIS
+
+Simply require the `assay/testunit` script, and include the `Assay::Assertions`
+mixin module into your test scope, where your test framework requires it (which 
+may be as simple as the toplevel namespace).
+
+  require 'assay/testunit'
+
+  include Assay::Assertions
+
+Now assertions can be made just as if you were using TestUnit.
+
+  assert_equal(10, 5+5)
+
+  assert_kind_of(Integer, 10)
+
+
+== LIMITATIONS
+
+Compatibility is not 100%, though it is very close. Compatibility will improve
+with future releases. Please feel _obligated_ to submit a patch if you need a
+missing a feature ;)
+
+Assay TestUnit is also a Ruby 1.9+ only library.
+
+
+== INSTALLATION
+
+To install with RubyGems simply open a console and type:
+
+  $ gem install assay-testunit
+
+Site installation with the tarball can be done with Ruby Setup
+(gem install setup). See http://rubyworks.github.com/setup.
+
+
+== COPYRIGHTS
+
+Copyright (c) 2012 Rubyworks
+
+This program is distributed under the terms of the *BSD-2-Clause* license.
+
+See COPYING.rdoc file for details.
+

data/lib/assay-testunit.rb

@@ -0,0 +1,10 @@
+require 'assay'
+require 'assay-testunit/assertions'
+
+# This module holds all assertion methods, which can be mixed into
+# one's testing scope (e.g. World).
+#
+module Assay::Assertions
+  include Assay::TestUnit::Assertions
+end
+

data/lib/assay-testunit.yml

@@ -0,0 +1,52 @@
+---
+source:
+- meta
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2012'
+  license: BSD-2-Clause
+replacements: []
+alternatives: []
+requirements:
+- name: assay
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+dependencies: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/assay-testunit.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/assay-testunit
+  docs: http://rubydoc.info/gems/assay-testunit
+  code: http://github.com/rubyworks/assay-testunit
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-01-18'
+summary: TestUnit on Assay
+title: Assay TestUnit
+version: 0.1.0
+name: assay-testunit
+description: ! 'Assay TestUnit defines a set of TestUnit-compatible assertion methods
+  which
+
+  depend on Assay''s assertion classes. This allows developers to change
+
+  test frameworks without having to change a slew of previously
+
+  defined assertions.'
+organization: Rubyworks
+date: '2012-01-25'

data/lib/assay-testunit/assertions.rb

@@ -0,0 +1,494 @@
+module Assay; end
+module Assay::TestUnit
+
+  # This module holds the Test::Unit assertion methods for Test::Unit
+  # compatibility.
+  #
+  # While it does not provide 100% of Test::Unit assertions at the moment,
+  # compatibility will improved with upcoming releases.
+  #
+  # @see http://test-unit.rubyforge.org/test-unit/en/
+  #
+  # @todo Should we adjust error message to be like Test::Units ?
+  #
+  module Assertions
+
+    #
+    #def assert_alias_method(object, alias_name, original_name, message = nil)
+    #end
+
+    #
+    # Passes if actual is like expected, where `like` means satisfyin any one 
+    # of `#===`, `#==`, `#eql?` or `#equal?` calls.
+    #
+    # This is not strictly a Test::Unit assertion but is added here to cover
+    # all of Assay's availabe assertion classes.
+    #
+    def assert_alike(exp, act, msg=nil)
+      LikeAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if actual is NOT like expected, where `like` means satisfyin any
+    # one of `#===`, `#==`, `#eql?` or `#equal?` calls.
+    #
+    def assert_not_alike(exp, act, msg=nil)
+      LikeAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    def assert_block(message="assert_block failed.", &block)
+      ExecutionAssay.assert!(:message=>message, &block)
+    end
+
+    #
+    # Passes if `boolean` is either `true` or `false`.
+    #
+    def assert_boolean(boolean, message=nil)
+      BooleanAssay.assert!(boolean, :message=>message)
+    end
+
+    #
+    # Passes if `boolean` is not either `true` or `false`.
+    #
+    def assert_not_boolean(boolean, message=nil)
+      BooleanAssay.refute!(boolean, :message=>message)
+    end
+
+    # Passes if `object` satisify compaision by `operator`.
+    #
+    def assert_compare(receiver, operator, operand, message=nil)
+      case operator.to_sym
+      when :<
+        LessAssay.assert!(receiver, operand, :message=>message, :backtrace=>caller)
+      when :<=
+        LessEqualAssay.assert!(receiver, operand, :message=>message, :backtrace=>caller)
+      when :>
+        MoreAssay.assert!(receiver, operand, :message=>message, :backtrace=>caller)
+      when :>=
+        MoreEqualAssay.assert!(receiver, operand, :message=>message, :backtrace=>caller)
+      when :==
+        EqualAssay.assert!(operand, receiver, :message=>message, :backtrace=>caller)
+      else
+        raise ArgumentError, "comparision operator must be one of <, <=, >, >= or '=='"
+      end
+    end
+
+    #
+    #
+    #
+    #def assert_const_defined(object, constant_name, message=nil)
+    #end
+
+    #
+    #
+    #
+    #def assert_not_const_defined(object, constant_name, message=nil)
+    #end
+
+    # Passes if object is empty.
+    #
+    #   assert_empty(object)
+    #
+    def assert_empty(exp, msg=nil)
+      EmptyAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if object is not empty.
+    #
+    #   refute_empty(object)
+    #
+    def assert_not_empty(exp, msg=nil)
+      EmptyAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if expected == +actual.
+    #
+    # Note that the ordering of arguments is important,
+    # since a helpful error message is generated when this
+    # one fails that tells you the values of expected and actual.
+    #
+    #   assert_equal 'MY STRING', 'my string'.upcase
+    #
+    def assert_equal(exp, act, msg=nil)
+      EqualAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if expected != actual
+    #
+    #  assert_not_equal 'some string', 5
+    #
+    def assert_not_equal(exp, act, msg=nil)
+       EqualAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #def assert_fail_assertion(message = nil) 
+    #end
+
+    #
+    # Passed if object is +false+.
+    #
+    #   assert_false(false)
+    #
+    def assert_false(exp, msg=nil)
+      FalseAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passed if object is not +false+.
+    #
+    #   assert_not_false(false)
+    #
+    def assert_not_false(exp, msg=nil)
+      FalseAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if expected and actual are equal within delta tolerance.
+    #
+    #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def assert_in_delta(exp, act, delta, msg=nil)
+      WithinAssay.assert!(act, exp, delta, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if expected and actual are equal not within delta tolerance.
+    #
+    #   assert_not_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    def assert_not_in_delta(exp, act, delta, msg=nil)
+      WithinAssay.refute!(act, exp, delta, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `exp` and `act` are within `epsilon`.
+    #
+    def assert_in_epsilon(exp, act, epsilon=0.001, message=nil)
+      exp = exp.to_f
+      if exp.zero?
+        delta = epsilon.to_f ** 2
+      else
+        delta = exp * epsilon.to_f
+      end
+      WithinAssay.assert!(act, exp, delta, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `exp` and `act` are NOT within `epsilon`.
+    #
+    def assert_not_in_epsilon(exp, act, epsilon=0.001, message=nil) 
+      exp = exp.to_f
+      if exp.zero?
+        delta = epsilon.to_f ** 2
+      else
+        delta = exp * epsilon.to_f
+      end
+      WithinAssay.refute!(act, exp, delta, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `collection` contains `member`.
+    #
+    def assert_includes(collection, member, message=nil) 
+      IncludeAssay.assert!(collection, member, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if `collection` does not contain `member`.
+    #
+    def assert_not_includes(collection, member, message=nil)
+      IncludeAssay.refute!(collection, member, :message=>message, :backtrace=>caller) 
+    end
+
+    #
+    # Passes if object is an instance of class.
+    #
+    #   assert_instance_of(String, 'foo')
+    #
+    def assert_instance_of(cls, obj, msg=nil)
+      InstanceAssay.assert!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object is not an instance of class.
+    #
+    #   assert_not_instance_of(String, 500)
+    #
+    def assert_not_instance_of(cls, obj, msg=nil)
+      InstanceAssay.refute!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object .kind_of? klass
+    #
+    #   assert_kind_of(Object, 'foo')
+    #
+    def assert_kind_of(cls, obj, msg=nil)
+      KindAssay.assert!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if object .kind_of? klass
+    #
+    #   assert_not_kind_of(Object, 'foo')
+    #
+    def assert_not_kind_of(cls, obj, msg=nil)
+      KindAssay.refute!(obj, cls, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if object matches pattern using `#=~` method.
+    #
+    #   assert_match(/\d+/, 'five, 6, seven')
+    #
+    def assert_match(pattern, string, msg=nil)
+      MatchAssay.assert!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if object does not match pattern using `#=~` method.
+    #
+    #   assert_no_match(/two/, 'one 2 three')
+    #
+    def assert_not_match(pattern, string, msg=nil)
+      MatchAssay.refute!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if object has no match pattern using `#!~` method.
+    #
+    #   assert_no_match(/two/, 'one 2 three')
+    #
+    def assert_no_match(pattern, string, msg=nil)
+      NoMatchAssay.assert!(string, pattern, :message=>msg, :backtrace=>caller)
+    end
+
+    ## Passes if object has a match pattern using `#!~` method.
+    ##
+    ##   assert_not_no_match(/two/, 'one two three')
+    ##
+    #def assert_not_no_match(pattern, string, msg=nil)
+    #  NoMatchAssay.refute!(string, pattern, :message=>msg, :backtrace=>caller)
+    #end
+
+    # Passed if object is +nil+.
+    #
+    #   assert_nil(nil)
+    #
+    def assert_nil(exp, msg=nil)
+      NilAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passed if object is not +nil+.
+    #
+    #   assert_not_nil(true)
+    #
+    def assert_not_nil(exp, msg=nil)
+      NilAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    def assert_predicate(object, predicate, message = nil) 
+      ExecutionAssay.assert!(:message=>message) do
+        object.__send__(predicate)
+      end
+    end
+
+    #
+    #
+    #
+    def assert_not_predicate(object, predicate, message = nil) 
+      ExecutionAssay.refute!(:message=>message) do
+        object.__send__(predicate)
+      end
+    end
+
+    #
+    # Passes if +object+ respond_to? +methods+.
+    #
+    #   assert_respond_to 'bugbear', :slice
+    #
+    def assert_respond_to(reciever, method, msg=nil)
+      RespondAssay.assert!(reciever, method, :message=>msg, :backtrace=>caller)
+    end
+    alias_method :assert_responds_to, :assert_respond_to
+
+    #
+    # Passes if +object+ does not respond_to? +methods+.
+    #
+    #   assert_not_respond_to 'bugbear', :slice
+    #
+    def assert_not_respond_to(reciever, method, msg=nil)
+      RespondAssay.refute!(reciever, method, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if +expected+ .eql? +actual+.
+    #
+    # Note that the ordering of arguments is important,
+    # since a helpful error message is generated when this
+    # one fails that tells you the values of expected and actual.
+    #
+    #   assert_equivalent 'MY STRING', 'my string'.upcase
+    #
+    def assert_equivalent(exp, act, msg=nil)
+      EqualityAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    # Passes if +criterion+ is NOT equivalent to +actual+ as tested using `#eql?`.
+    #
+    #  assert_not_equivalent 1, 1.0
+    #
+    def assert_not_equivalent(criterion, act, msg=nil)
+      EqualityAssay.refute!(act, criterion, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    # TODO: Is this supposed to be restricted in some way?
+    def assert_operator(receiver, operator, operand, message=nil) 
+      ExecutionAssay.assert!(:message=>message, :backtrace=>caller) do
+        receiver.__send__(operator, operand)
+      end
+    end
+
+    #
+    #
+    #
+    def assert_path_exist(path, message=nil)
+      PathAssay.assert!(path, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    def assert_path_not_exist(path, message=nil) 
+      PathAssay.refute!(path, :message=>message, :backtrace=>caller)
+    end
+
+    #
+    # Passes if the block raises a given exception.
+    #
+    #   assert_raise RuntimeError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_raise(exception, message=nil, &block)
+      RaiseAssay.assert!(exception, :message=>message, :backtrace=>caller, &block)
+    end
+
+    alias_method :assert_raises, :assert_raise
+
+    #
+    # Passes if the block *does not* raise a given exceptions.
+    #
+    #   assert_not_raised IOError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_not_raised(exception, message=nil, &block) #:yeild:
+      RaiseAssay.refute!(exception, :message=>message, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if the block yields successfully.
+    #
+    #   assert_nothing_raised "Couldn't do the thing" do
+    #     do_the_thing
+    #   end
+    #
+    def assert_nothing_raised(message=nil, &block)
+      RescueAssay.refute!(Exception, :message=>message, :backtrace=>caller, &block)
+    end
+
+    #
+    # Passes if the block raises a given exception.
+    #
+    #   assert_raise_kind_of RuntimeError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    def assert_raise_kind_of(exception_class, message=nil, &block)
+      RescueAssay.assert!(exception_class, :message=>message, :backtrace=>caller, &block)
+    end
+
+    #
+    #def assert_raise_message(*args, &block) 
+    #end
+
+    #
+    # Passes if actual is the same exact object as expected.
+    #
+    #   assert_same(object, object)
+    #
+    def assert_same(exp, act, msg=nil)
+      IdentityAssay.assert!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passes if actual is not the same exact object as expected.
+    #
+    #   assert_not_same(object, other)
+    #
+    def assert_not_same(exp, act, msg=nil)
+      IdentityAssay.refute!(act, exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    #
+    #
+    #def assert_send(send_array, message=nil)
+    #end
+
+    #
+    # Passes if the block throws `expected` object.
+    #
+    #   assert_throw :done do
+    #     throw :done
+    #   end
+    #
+    def assert_throw(expected, msg=nil, &blk)
+      ThrowAssay.assert!(expected, :message=>msg, :backtrace=>caller, &blk)
+    end
+
+    alias_method :assert_throws, :assert_throw
+
+    #
+    # Passes if the block does not throws `expected` object.
+    #
+    #   assert_not_thrown :done do
+    #     throw :chimp
+    #   end
+    #
+    def assert_not_thrown(expected, msg=nil, &blk)
+      ThrowAssay.refute!(expected, :message=>msg, :backtrace=>caller, &blk)
+    end
+
+    #
+    #
+    #
+    def assert_nothing_thrown(message=nil, &blk)
+      ThrowAssay.refute!(nil, :message=>message, &blk)
+    end
+
+    #
+    # Passed if object is +true+.
+    #
+    def assert_true(exp, msg=nil)
+      TrueAssay.assert!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+    #
+    # Passed if object is not +true+.
+    #
+    #   assert_not_true(false)
+    #
+    def assert_not_true(exp, msg=nil)
+      TrueAssay.refute!(exp, :message=>msg, :backtrace=>caller)
+    end
+
+  end
+
+end

data/lib/assay/testunit.rb

@@ -0,0 +1 @@
+require 'assay-testunit'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: assay-testunit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: assay
+  requirement: &12135040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12135040
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &12125400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12125400
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &12115700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12115700
+description: ! 'Assay TestUnit defines a set of TestUnit-compatible assertion methods
+  which
+
+  depend on Assay''s assertion classes. This allows developers to change
+
+  test frameworks without having to change a slew of previously
+
+  defined assertions.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- HISTORY.rdoc
+- DEMOS.rdoc
+- README.rdoc
+- COPYING.rdoc
+files:
+- .ruby
+- .yardopts
+- lib/assay/testunit.rb
+- lib/assay-testunit/assertions.rb
+- lib/assay-testunit.rb
+- lib/assay-testunit.yml
+- HISTORY.rdoc
+- DEMOS.rdoc
+- README.rdoc
+- COPYING.rdoc
+homepage: http://rubyworks.github.com/assay-testunit
+licenses:
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: TestUnit on Assay
+test_files: []