microtest 0.1.0

data/.gemspec

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gemspec|
+
+  manifest = Dir.glob('manifest{,.txt)', File::FNM_CASEFOLD).first
+
+  scm = case
+        when File.directory?('.git')
+          :git
+        end
+
+  files = case
+          when manifest
+           File.readlines(manifest).
+             map{ |line| line.srtip }.
+             reject{ |line| line.empty? || line[0,1] == '#' }
+          when scm == :git
+           `git ls-files -z`.split("\0")
+          else
+            Dir.glob('{**/}{.*,*}')  # TODO: be more specific using standard locations ?
+          end.select{ |path| File.file?(path) }
+
+  patterns = {
+    :bin_files  => 'bin/*',
+    :lib_files  => 'lib/{**/}*.rb',
+    :ext_files  => 'ext/{**/}extconf.rb',
+    :doc_files  => '*.{txt,rdoc,md,markdown,tt,textile}',
+    :test_files => '{test/{**/}*_test.rb,spec/{**/}*_spec.rb}'
+  }
+
+  glob_files = lambda { |pattern|
+    Dir.glob(pattern).select { |path|
+      File.file?(path) && files.include?(path)
+    }
+  }
+
+  #files = glob_files[patterns[:files]]
+
+  executables = glob_files[patterns[:bin_files]].map do |path|
+                  File.basename(path)
+                end
+
+  extensions = glob_files[patterns[:ext_files]].map do |path|
+                 File.basename(path)
+               end
+
+  metadata = YAML.load_file('.ruby')
+
+  # build-out the gemspec
+
+  case metadata['revision']
+  when 0
+    gemspec.name        = metadata['name']
+    gemspec.version     = metadata['version']
+    gemspec.summary     = metadata['summary']
+    gemspec.description = metadata['description']
+
+    metadata['authors'].each do |author|
+      gemspec.authors << author['name']
+
+      if author.has_key?('email')
+        if gemspec.email
+          gemspec.email << author['email']
+        else
+          gemspec.email = [author['email']]
+        end
+      end
+    end
+
+    gemspec.licenses = metadata['licenses']
+
+    metadata['requirements'].each do |req|
+      name    = req['name']
+      version = req['version']
+      groups  = req['groups'] || []
+
+      if md = /^(.*?)([+-~])$/.match(version)
+        version = case md[2]
+                    when '+' then ">= #{$1}"
+                    when '-' then "< #{$1}"
+                    when '~' then "~> #{$1}"
+                    else version
+                  end
+      end
+
+      #development = req['development']
+      #if development
+      #  # populate development dependencies
+      #  if gemspec.respond_to?(:add_development_dependency)
+      #    gemspec.add_development_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #else
+      #  # populate runtime dependencies  
+      #  if gemspec.respond_to?(:add_runtime_dependency)
+      #    gemspec.add_runtime_dependency(name,*version)
+      #  else
+      #    gemspec.add_dependency(name,*version)
+      #  end
+      #end
+
+      if groups.empty? or groups.include?('runtime')
+        # populate runtime dependencies  
+        if gemspec.respond_to?(:add_runtime_dependency)
+          gemspec.add_runtime_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      else
+        # populate development dependencies
+        if gemspec.respond_to?(:add_development_dependency)
+          gemspec.add_development_dependency(name,*version)
+        else
+          gemspec.add_dependency(name,*version)
+        end
+      end
+    end
+
+    # convert external dependencies into a requirements
+    if metadata['external_dependencies']
+      ##gemspec.requirements = [] unless metadata['external_dependencies'].empty?
+      metadata['external_dependencies'].each do |req|
+        gemspec.requirements << req.to_s
+      end
+    end
+
+    # determine homepage from resources
+    homepage = metadata['resources'].find{ |key, url| key =~ /^home/ }
+    gemspec.homepage = homepage.last if homepage
+
+    gemspec.require_paths        = metadata['load_path'] || ['lib']
+    gemspec.post_install_message = metadata['install_message']
+
+    # RubyGems specific metadata
+    gemspec.files       = files
+    gemspec.extensions  = extensions
+    gemspec.executables = executables
+
+    if Gem::VERSION < '1.7.'
+      gemspec.default_executable = gemspec.executables.first
+    end
+
+    gemspec.test_files = glob_files[patterns[:test_files]]
+
+    unless gemspec.files.include?('.document')
+      gemspec.extra_rdoc_files = glob_files[patterns[:doc_files]]
+    end
+  end
+end

data/.ruby

@@ -0,0 +1,46 @@
+---
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+copyrights:
+- holder: Thomas Sawyer
+  year: '2011'
+  license: BSD-2-Clause
+replacements: []
+conflicts: []
+requirements:
+- name: test
+- name: detroit
+  groups:
+  - build
+  development: true
+- name: reap
+  groups:
+  - build
+  development: true
+- name: qed
+  groups:
+  - test
+  development: true
+dependencies: []
+repositories:
+- uri: git://github.com/proutils/microtest.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/microtest
+  code: http://github.com/rubyworks/microtest
+load_path:
+- lib
+extra:
+  manifest: MANIFEST
+alternatives: []
+revision: 0
+name: microtest
+title: MicroTest
+summary: Microminal TestUnit-style Test Framework
+description: MicroTest is very small Test::Unit/MiniTest compatbile test framework
+  that run on top of the Ruby Universal Test Harness (Ruby Test).
+organization: RubyWorks
+version: 0.1.0
+date: '2011-08-11'

data/Assembly

@@ -0,0 +1,46 @@
+---
+github:
+  active: true
+
+gem:
+  active: true
+
+dnote:
+  labels: ~
+  output: log/NOTES.rdoc
+
+yard:
+  yardopts: true
+
+qed:
+  files    : ~
+  #exclude : ~
+  #loadpath: ~
+  #requires: ~
+  #live    : false   
+  active   : false
+
+qedoc:
+  files : spec/
+  output: QED.rdoc
+  active: false
+
+vclog:
+  output: log/ChangeLog.rdoc
+  active: false
+
+email:
+  service: Email
+  file   : ~
+  subject: ~
+  mailto : 
+    - ruby-talk@ruby-lang.org
+    - rubyworks-mailinglist@googlegroups.com
+  from   : <%= ENV['EMAIL_ACCOUNT'] %>
+  server : <%= ENV['EMAIL_SERVER'] %>
+  port   : <%= ENV['EMAIL_PORT'] %>
+  account: <%= ENV['EMAIL_ACCOUNT'] %>
+  domain : <%= ENV['EMAIL_DOMAIN'] %>
+  login  : <%= ENV['EMAIL_LOGIN'] %>
+  secure : <%= ENV['EMAIL_SECURE'] %>
+

data/COPYING.rdoc

@@ -0,0 +1,31 @@
+= COPYRIGHT NOTICES
+
+== MicroTest
+
+Copyright:: (c) 2011 Thomas Sawyer, RubyWorks
+License:: BSD-2-Clause
+Website:: http://rubyworks.github.com/microtest
+
+    Copyright 2011 Thomas Sawyer. All rights reserved.
+
+    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/HISTORY.md

@@ -0,0 +1,9 @@
+# Release History
+
+## 0.1.0 / 2011-08-11
+
+This first release covers basic compatability with Test::Unit and MiniTest.
+
+Changes:
+
+* Happy Birthday.

data/MANIFEST

@@ -0,0 +1,9 @@
+#!mast .ruby .yaropts bin lib spec test [A-Z][A-Z]*
+.ruby
+lib/microtest/assertions.rb
+lib/microtest/unit.rb
+lib/microtest.rb
+PROFILE
+HISTORY.md
+README.md
+COPYING.rdoc

data/PROFILE

@@ -0,0 +1,30 @@
+--- 
+name   : microtest
+title  : MicroTest
+summary: Microminal TestUnit-style Test Framework
+authors:
+  - Thomas Sawyer <transfire@gmail.com>
+
+description:
+  MicroTest is very small Test::Unit/MiniTest compatbile
+  test framework that run on top of the Ruby Universal
+  Test Harness (Ruby Test).
+
+resources:
+  home: http://rubyworks.github.com/microtest
+  code: http://github.com/rubyworks/microtest
+
+repositories:
+  upstream: git://github.com/proutils/microtest.git
+
+requirements:
+  - test
+  - detroit  (build)
+  - reap     (build)
+  - qed      (test)
+
+organization: RubyWorks
+
+copyrights:
+  - 2011 Thomas Sawyer (BSD-2-Clause)
+

data/README.md

@@ -0,0 +1,49 @@
+# MicroTest
+
+## Description
+
+MicroTest is a minimal Test::Unit and MiniTest campatible 
+test framework that runs on top of Ruby Test.
+
+## Synopsis
+
+MicroTests are written in essentially the same manner as Ruby standard
+test frameworks.
+
+```ruby
+require 'microtest/assertions'  # for legacy assertion methods
+
+class ExampleTest < MicroTest::TestCase
+
+  #
+  def setup
+    @a = 1
+  end
+
+  #
+  def test_alpha_is_one
+    assert_equal(1, @a)
+  end
+
+end
+```
+
+For drop in compatability with Test::Unit, load `microtest/test/unit`.
+
+```ruby
+require 'microtest/unit'
+
+class ExampleTest < Test::Unit::TestCase
+  ...
+end
+```
+
+# Copyrights and Licensing
+
+Copyright (c) 2011 Thomas Sawyer, Rubyworks
+
+MicroTest is distributes under the terms of the **FreeBSD** license.
+
+See COPYING.rdoc for more information.
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/microtest.rb

@@ -0,0 +1,77 @@
+module MicroTest
+
+  #
+  def self.natural_names
+    @natural_names ||= nil
+  end
+
+  #
+  def self.natural_names=(boolean)
+    @natural_names = !!boolean
+  end
+
+  # The World serves as a base class in which the end-tester can
+  # add univerally available test helpers for all test cases.
+  class World
+  end
+
+  #
+  class TestCase < World
+
+    def self.inherited(subclass)
+      subclass.new
+    end
+
+    #
+    def self.new(*a,&b)
+      $TEST_SUITE << super(*a,&b)
+    end
+
+    #
+    def to_s
+      self.class.name
+    end
+
+    #
+    def call(&cont)
+      setup
+      cont.call
+      teardown
+    end
+
+    #
+    def each
+      methods.each do |m|
+        next unless m.to_s.start_with?('test_')
+        yield(TestMethod.new(method(m)))
+      end
+    end
+
+    #
+    def setup
+    end
+
+    #
+    def teardown
+    end
+
+  end
+
+  #
+  class TestMethod
+    def initialize(method)
+      @method = method
+    end
+
+    def call
+      @method.call
+    end
+
+    def to_s
+      name = @method.name.to_s  
+      name.gsub!('_', ' ') if MicroTest.natural_names
+      return name
+    end
+  end
+
+end

data/lib/microtest/assertions.rb

@@ -0,0 +1,350 @@
+module MicroTest
+
+  # Legacy Assertions
+  #
+  # This module provides a compatibility layer for Test::Unit/MiniTest.
+  # This is an optional module and must be loaded on it's own.
+  #
+  # Note that two methods are not provided, +#assert_nothing_raised+,
+  # and +#assert_nothing_thrown+.
+  #
+  module Assertions
+
+    # Private method upon which all of the legacy assertions are based
+    # (except for #assert itself).
+    #
+    # @raise [Assertion] If test fails.
+    #
+    # @return nothing
+    def __assert__(test, msg=nil)
+      msg = "failed assertion (no message given)" unless msg
+      raise Assertion.new(msg, :backtrace=>caller[1..-1]) unless test
+    end
+
+    private :__assert__
+
+    # The assertion upon which all other assertions are based.
+    #
+    # @example
+    #   assert [1, 2].include?(5)
+    #
+    # @return [Assertor] if `test` not given
+    def assert(test, msg=nil)
+      msg = "failed assertion (no message given)" unless msg
+      raise Assertion.new(msg, :backtrace=>caller) unless test
+    end
+
+    # Passes if the block yields true.
+    #
+    # @example
+    #   assert_block "Couldn't do the thing" do
+    #     do_the_thing
+    #   end
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_block(msg=nil) # :yields:
+      test = ! yield
+      msg = "assertion failed" unless msg
+      __assert__(test, msg)
+    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.
+    #
+    # @example
+    #   assert_equal 'MY STRING', 'my string'.upcase
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_equal(exp, act, msg=nil)
+      test = (exp == act)
+      msg  = "Expected #{act.inspect} to be equal to #{exp.inspect}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if expected_float and actual_float are equal within delta tolerance.
+    #
+    # @example
+    #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_in_delta(exp, act, delta, msg=nil)
+      test = (exp.to_f - act.to_f).abs <= delta.to_f
+      msg  = "Expected #{exp} to be within #{delta} of #{act}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if object .instance_of? klass
+    #
+    # @example
+    #   assert_instance_of String, 'foo'
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_instance_of(cls, obj, msg=nil)
+      test = (cls === obj)
+      msg  = "Expected #{obj} to be a #{cls}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if object .kind_of? klass
+    #
+    # @example
+    #   assert_kind_of Object, 'foo'
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_kind_of(cls, obj, msg=nil)
+      test = obj.kind_of?(cls)
+      msg  = "Expected #{obj.inspect} to be a kind of #{cls}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if string =~ pattern.
+    #
+    # @example
+    #   assert_match(/\d+/, 'five, 6, seven')
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_match(exp, act, msg=nil)
+      test = (act =~ exp)
+      msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if object is nil.
+    #
+    # @example
+    #   assert_nil [1, 2].uniq!
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_nil(obj, msg=nil)
+      test = obj.nil?
+      msg  = "Expected #{obj.inspect} to be nil" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if regexp !~ string
+    #
+    # @example
+    #   assert_no_match(/two/, 'one 2 three')
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_no_match(exp, act, msg=nil)
+      test = (act !~ exp)
+      msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if expected != actual
+    #
+    # @example
+    #  assert_not_equal 'some string', 5
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_not_equal(exp, act, msg=nil)
+      test = (exp != act)
+      msg  = "Expected #{act.inspect} to not be equal to #{exp.inspect}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if ! object .nil?
+    #
+    # @example
+    #   assert_not_nil '1 two 3'.sub!(/two/, '2')
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_not_nil(obj, msg=nil)
+      test = ! obj.nil?
+      msg  = "Expected #{obj.inspect} to not be nil" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if ! actual .equal? expected
+    #
+    # @example
+    #   assert_not_same Object.new, Object.new
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_not_same(exp, act, msg=nil)
+      test = ! exp.equal?(act)
+      msg  = "Expected #{act.inspect} to not be the same as #{exp.inspect}" unless msg
+      __assert__(test, msg)
+    end
+
+    # Compares the +object1+ with +object2+ using operator.
+    #
+    # Passes if object1.send(operator, object2) is true.
+    #
+    # @example
+    #   assert_operator 5, :>=, 4
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_operator(o1, op, o2, msg="")
+      test = o1.__send__(op, o2)
+      msg = "Expected #{o1}.#{op}(#{o2}) to be true" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if the block raises one of the given exceptions.
+    #
+    # @example
+    #   assert_raise RuntimeError, LoadError do
+    #     raise 'Boom!!!'
+    #   end
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_raises(*args)
+      msg = (Module === args.last ? nil : args.pop)
+      begin
+        yield
+        msg = "Expected #{exp} to be raised" unless msg
+        __assert__(false, msg)
+      rescue Exception => e
+        test = (exp === e)
+        msg  = "Expected #{exp} to be raised, but got #{e.class}" unless msg
+        __assert__(test, msg)
+        return e
+      end
+    end
+
+    alias_method :assert_raise, :assert_raises
+
+    # Provides a way to assert that a procedure
+    # <i>does not</i> raise an exception.
+    #
+    # @example
+    #   refute_raises(StandardError){ raise }
+    #
+    #def assert_raises!(exception, &block)
+    #  begin
+    #    block.call(*a)
+    #  rescue exception
+    #    raise Assertion
+    #  end
+    #end
+    #alias_method :refute_raises, :assert_raises!
+
+    # Passes if +object+ respond_to? +method+.
+    #
+    # @example
+    #   assert_respond_to 'bugbear', :slice
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_respond_to(obj, meth, msg=nil)
+      msg  = "Expected #{obj} (#{obj.class}) to respond to ##{meth}" unless msg
+      #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+      #obj, meth = meth, obj if flip
+      test = obj.respond_to?(meth)
+      __assert__(test, msg)
+    end
+
+    # Passes if +actual+ .equal? +expected+ (i.e. they are the same instance).
+    #
+    # @example
+    #   o = Object.new
+    #   assert_same(o, o)
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_same(exp, act, msg=nil)
+      msg  = "Expected #{act.inspect} to be the same as #{exp.inspect}" unless msg
+      test = exp.equal?(act)
+      __assert__(test, msg)
+    end
+
+    # Passes if the method send returns a true value.
+    # The parameter +send_array+ is composed of:
+    #
+    # * A receiver
+    # * A method
+    # * Arguments to the method
+    #
+    # @example
+    #   assert_send [[1, 2], :include?, 4]
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_send(send_array, msg=nil)
+      r, m, *args = *send_array
+      test = r.__send__(m, *args)
+      msg  = "Expected #{r}.#{m}(*#{args.inspect}) to return true" unless msg
+      __assert__(test, msg)
+    end
+
+    # Passes if the block throws expected_symbol
+    #
+    # @example
+    #   assert_throws :done do
+    #     throw :done
+    #   end
+    #
+    # @raise [Assertion] if test fails
+    #
+    # @return nothing
+    def assert_throws(sym, msg=nil)
+      msg  = "Expected #{sym} to have been thrown" unless msg
+      test = true
+      catch(sym) do
+        begin
+          yield
+        rescue ArgumentError => e     # 1.9 exception
+          default += ", not #{e.message.split(/ /).last}"
+        rescue NameError => e         # 1.8 exception
+          default += ", not #{e.name.inspect}"
+        end
+        test = false
+      end
+      __assert__(test, msg)
+    end
+
+    # Flunk always fails.
+    #
+    # @example
+    #   flunk 'Not done testing yet.'
+    #
+    # @raise [Assertion] always
+    #
+    # @return nothing
+    def flunk(msg=nil)
+      __assert__(false, msg)
+    end
+
+  end
+
+  #
+  class World
+    include Assertions
+  end
+
+end

data/lib/microtest/unit.rb

@@ -0,0 +1,8 @@
+require 'microtest'
+
+module Test
+  module Unit
+    TestCase = MicroTest::TestCase
+  end
+end
+

data/try/.test

@@ -0,0 +1,2 @@
+$:.unshift(File.dirname(__FILE__)+'/../lib')
+

data/try/test_example.rb

@@ -0,0 +1,14 @@
+require 'microtest'
+require 'microtest/assertions'
+
+class ExampleTest < MicroTest::TestCase
+
+  def setup
+    @a = 1
+  end
+
+  def test_example_of_passing_test
+    assert_equal(1, @a)
+  end
+
+end

data/try/test_unit_example.rb

@@ -0,0 +1,15 @@
+require 'microtest/unit'
+require 'microtest/assertions'
+
+class ExampleTest < Test::Unit::TestCase
+
+  def setup
+    @a = 1
+  end
+
+  def test_example_of_passing_test
+    assert_equal(1, @a)
+  end
+
+end
+

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: microtest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: test
+  requirement: &12648320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12648320
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &12646440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12646440
+- !ruby/object:Gem::Dependency
+  name: reap
+  requirement: &15175400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15175400
+- !ruby/object:Gem::Dependency
+  name: qed
+  requirement: &15174900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15174900
+description: MicroTest is very small Test::Unit/MiniTest compatbile test framework
+  that run on top of the Ruby Universal Test Harness (Ruby Test).
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- COPYING.rdoc
+- HISTORY.md
+- README.md
+files:
+- .gemspec
+- .ruby
+- Assembly
+- COPYING.rdoc
+- HISTORY.md
+- MANIFEST
+- PROFILE
+- README.md
+- VERSION
+- lib/microtest.rb
+- lib/microtest/assertions.rb
+- lib/microtest/unit.rb
+- try/.test
+- try/test_example.rb
+- try/test_unit_example.rb
+homepage: http://rubyworks.github.com/microtest
+licenses: []
+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.5
+signing_key: 
+specification_version: 3
+summary: Microminal TestUnit-style Test Framework
+test_files: []