testicles 0.1

data/.gitignore

@@ -0,0 +1 @@
+doc

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2009 Nicolas Sanguinetti
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,139 @@
+= Testicles, the ballsy test framework
+
+    require "testicles"
+
+    class UserTest < Testicles::TestCase
+      setup do
+        @user = User.new(:name => "John Doe", :email => "john@example.org")
+      end
+
+      test "has a name" do
+        assert @user.name == "John Doe"
+      end
+
+      test "has an email" do
+        assert @user.email == "john@example.org"
+      end
+    end
+
+Testicles is a small, simple, and easy-to-extend testing framework for ruby. It
+was written as a replacement for Test::Unit, given how awful its code is, and
+how difficult it is to extend in order to add new features.
+
+I believe in minimalistic software, which is easily understood, easy to test,
+and specially, easy to extend for third parties. That's where I'm aiming with
+Testicles.
+
+== Assertions
+
+You probably wonder why the example doesn't have any assertion other than
++assert+. Why not +assert_equal+, right? Well, the idea is to keep it slim. If
+you want to use more assertions, you're free to define your own. Also, since it
+uses the same assertion API as Test::Unit, you can just require its assertions:
+
+    require "testicles"
+    require "test/unit/assertions"
+
+    class UserTest < Testicles::TestCase
+      include Test::Unit::Assertions
+
+      # now you can use all of Test::Unit assertions. For free.
+    end
+
+You can even define rspec-like matchers if you want.
+
+== Setup and teardown
+
+If you need to run code before or after each test, declare a +setup+ or
++teardown+ block (respectively.)
+
+    class UserTest < Testicles::TestCase
+      setup do # this runs before each test
+        @user = User.create(:name => "John")
+      end
+
+      teardown do # this runs after each test
+        @user.destroy
+      end
+    end
+
++setup+ and +teardown+ blocks are evaluated in the same context as your test,
+which means any instance variables defined in any of them are available in the
+rest.
+
+You can also use +global_setup+ and +global_teardown+ to run code only once per
+test case. +global_setup+ blocks will run once before the first test is run, and
++global_teardown+ will run after all the tests have been run.
+
+These methods, however, are dangerous, and should be used with caution, as
+they might introduce dependencies between your tests if you don't write
+your tests properly. Make sure that any state modified by code run in a
++global_setup+ or +global_teardown+ isn't changed in any of your tests.
+
+Also, you should be aware that the code of +global_setup+ and +global_teardown+
+blocks isn't evaluated in the same context as your tests and normal
++setup+/+teardown+ blocks are, so you can't share instance variables between
+them.
+
+== Nested contexts
+
+Break down your test into logical chunks with nested contexts:
+
+    class UserTest < Testicles::TestCase
+      setup do
+        @user = User.make
+      end
+
+      context "validations" do
+        test "validates name" do
+          @user.name = nil
+          assert !@user.valid?
+        end
+
+        # etc, etc
+      end
+
+      context "something else" do
+        # your get the idea
+      end
+    end
+
+Any +setup+ or +teardown+ blocks you defined in a context will run in that
+context and in _any_ other context nested in it.
+
+== Pending tests
+
+There are two ways of marking a test as pending. You can declare a test with no
+body:
+
+    class SomeTest < Testicles::TestCase
+      test "this test will be marked as pending"
+
+      test "this tests is also pending"
+
+      test "this test isn't pending" do
+        assert true
+      end
+    end
+
+Or you can call the +pending+ method from inside your test.
+
+    class SomeTest < Testicles::TestCase
+      test "this test is pending" do
+        pending "oops, this doesn't work"
+        assert false
+      end
+    end
+
+== (Best|Worst) name ever
+
+I personally believe the name is full of win. But I understand it's not the
+most marketable name :)
+
+If you hate it, suggest a better name. Or just fork it and name your version
+different, it's open source, after all.
+
+== Legal
+
+Author:: Nicolás Sanguinetti — http://nicolassanguinetti.info
+License:: MIT (see bundled LICENSE file for more info)

data/Rakefile

@@ -0,0 +1,18 @@
+begin
+  require "hanna/rdoctask"
+rescue LoadError
+  require "rake/rdoctask"
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.title = "API Documentation for Testicles"
+  rd.rdoc_files.include("README.rdoc", "LICENSE", "lib/**/*.rb")
+  rd.rdoc_dir = "doc"
+end
+
+begin
+  require "mg"
+  MG.new("testicles.gemspec")
+rescue LoadError
+end

data/lib/testicles.rb

@@ -0,0 +1,80 @@
+module Testicles
+  # Exception raised when an assertion fails. See TestCase#assert
+  class AssertionFailed < StandardError; end
+
+  # Exception raised to mark a test as pending. See TestCase#pending
+  class Pending < StandardError; end
+
+  # Register a new Report. This will make your report available to Testicles,
+  # allowing you to run your tests through this report. For example
+  #
+  #     module Testicles
+  #       class Reports::MyAwesomeReport < Report
+  #       end
+  #
+  #       add_report :awesomesauce, MyAwesomeReport
+  #     end
+  #
+  # See Testicles.report_with to see how to select which report will be used.
+  def self.add_report(name, report)
+    available_reports[name] = report
+  end
+
+  # Register a test case to be run with Testicles. This is done automatically
+  # whenever you subclass Testicles::TestCase, so you probably shouldn't pay
+  # much attention to this method.
+  def self.add_test_case(test_case)
+    available_test_cases << test_case
+  end
+
+  # Set to +false+ to avoid running tests +at_exit+. Default is +true+.
+  def self.autorun=(flag)
+    @autorun = flag
+  end
+
+  # Checks to see if tests should be run +at_exit+ or not. Default is +true+.
+  # See Testicles.autorun=
+  def self.autorun?
+    !!@autorun
+  end
+
+  # Run all registered test cases through the selected report. You can pass
+  # arguments to the Report constructor here.
+  #
+  # See Testicles.add_test_case and Testicles.report_with
+  def self.run_all_tests!(*report_args)
+    report = available_reports.fetch(@report).new(*report_args)
+    Runner.new(report).run(*available_test_cases)
+  end
+
+  # Select the name of the Report to use when running tests. See
+  # Testicles.add_report for more information on registering a report.
+  #
+  # The default report is Testicles::Reports::Progress
+  def self.report_with(name)
+    @report = name
+  end
+
+  self.autorun = true
+  self.report_with(:progress)
+
+  def self.available_test_cases
+    @test_cases ||= []
+  end
+  private_class_method :available_test_cases
+
+  def self.available_reports
+    @available_reports ||= {}
+  end
+  private_class_method :available_reports
+end
+
+require "testicles/test_case"
+require "testicles/runner"
+require "testicles/report"
+require "testicles/reports"
+require "testicles/reports/progress"
+
+at_exit do
+  Testicles.run_all_tests! if Testicles.autorun?
+end

data/lib/testicles/report.rb

@@ -0,0 +1,173 @@
+module Testicles
+  class Report
+    # Seconds taken to run the test suite.
+    #
+    # TODO: this doesn't belong here, it's being set from within the test
+    # runner. But we need the value here.
+    attr_accessor :time_elapsed
+
+    # Define an event handler for your report. The different events fired in a
+    # report's life cycle are:
+    #
+    # :start::     Fired by the runner when starting the whole test suite.
+    # :enter::     Fired by the runner when starting a particular test case. It
+    #              will get the test case as an argument.
+    # :assertion:: Fired by a test each time an assertion is run.
+    # :pass::      Fired by a test after it runs successfully without errors.
+    #              It will get an instance of PassedTest as an argument.
+    # :pending::   Fired by a test which doesn't provide a test block or which
+    #              calls TestCase#pending. It will get an instance of
+    #              PendingTest as an argument.
+    # :failure::   Fired by a test in which an assertion failed. It will get an
+    #              instance of FailedTest as an argument.
+    # :error::     Fired by a test where an uncaught exception was found. It
+    #              will get an instance of ErroredTest as an argument.
+    # :exit::      Fired by the runner each time a test case finishes. It will
+    #              take the test case as an argument.
+    # :end::       Fired by the runner at the end of the whole test suite.
+    #
+    # The event handler will receive the report as a first argument, plus any
+    # arguments documented above (depending on the event). It will also ensure
+    # that any handler for the same event declared on an ancestor class is run.
+    def self.on(event, &block)
+      define_method(:"on_#{event}") do |*args|
+        begin
+          super(*args)
+        rescue NoMethodError
+        end
+
+        block.call(self, *args)
+      end
+    end
+
+    on :pass do |report, passed_test|
+      report.passes << passed_test
+    end
+
+    on :pending do |report, pending_test|
+      report.pendings << pending_test
+    end
+
+    on :failure do |report, failed_test|
+      report.failures << failed_test
+      report.failures_and_errors << failed_test
+    end
+
+    on :error do |report, errored_test|
+      report.errors << errored_test
+      report.failures_and_errors << errored_test
+    end
+
+    on :assertion do |report|
+      report.add_assertion
+    end
+
+    # Run a test and report if it passes, fails, or is pending. Takes the name
+    # of the test as an argument. You can avoid reporting a passed test by
+    # passing +false+ as a second argument.
+    def report(name, report_success=true)
+      yield
+      on_pass(PassedTest.new(name)) if report_success
+    rescue Pending => e
+      on_pending(PendingTest.new(name, e))
+    rescue AssertionFailed => e
+      on_failure(FailedTest.new(name, e))
+    rescue Exception => e
+      on_error(ErroredTest.new(name, e))
+    end
+
+    # List all the tests (as PendingTest instances) that were pending.
+    def pendings
+      @pendings ||= []
+    end
+
+    # List all the tests (as PassedTest instances) that passed.
+    def passes
+      @passes ||= []
+    end
+
+    # List all the tests (as FailedTest instances) that failed an assertion.
+    def failures
+      @failures ||= []
+    end
+
+    # List all the tests (as ErroredTest instances) that raised an unrescued
+    # exception.
+    def errors
+      @errors ||= []
+    end
+
+    # Aggregated and ordered list of tests that either failed an assertion or
+    # raised an unrescued exception. Useful for displaying back to the user.
+    def failures_and_errors
+      @failures_and_errors ||= []
+    end
+
+    # Log an assertion was run (whether it succeeded or failed.)
+    def add_assertion
+      @assertions ||= 0
+      @assertions += 1
+    end
+
+    # Number of assertions run during the report.
+    def assertions
+      @assertions || 0
+    end
+
+    # Amount ot tests run (whether passed, pending, failed, or errored.)
+    def total_tests
+      passes.size + failures.size + errors.size + pendings.size
+    end
+
+    # Encapsulate the relevant information for a test that passed.
+    class PassedTest
+      # Name of the test that passed. Useful for certain reports.
+      attr_reader :test_name
+
+      def initialize(test_name) #:nodoc:
+        @test_name = test_name
+      end
+    end
+
+    # Encapsulates the relevant information for a test which failed an
+    # assertion.
+    class FailedTest < PassedTest
+      def initialize(test_name, error) #:nodoc:
+        super(test_name)
+        @error = error
+      end
+
+      # Message with which it failed the assertion
+      def error_message
+        @error.message
+      end
+
+      # Line of the file where the assertion failed
+      def line
+        backtrace.first.split(":")[1]
+      end
+
+      # File where the assertion failed
+      def file
+        backtrace.first.split(":")[0]
+      end
+
+      # Backtrace of the assertion
+      def backtrace
+        @error.backtrace
+      end
+    end
+
+    # Encapsulates the relevant information for a test which raised an
+    # unrescued exception.
+    class ErroredTest < FailedTest
+    end
+
+    # Encapsulates the relevant information for a test that the user marked as
+    # pending.
+    class PendingTest < FailedTest
+      # Message passed to TestCase#pending, if any.
+      alias_method :pending_message, :error_message
+    end
+  end
+end

data/lib/testicles/reports.rb

@@ -0,0 +1,2 @@
+module Testicles::Reports # :nodoc:
+end

data/lib/testicles/reports/progress.rb

@@ -0,0 +1,111 @@
+module Testicles
+  # The +:progress+ report will output a +.+ for each passed test in the suite,
+  # a +P+ for each pending test, an +F+ for each test that failed an assertion,
+  # and an +E+ for each test that raised an unrescued exception.
+  #
+  # At the end of the suite it will output a list of all pending tests, with
+  # files and line numbers, and after that a list of all failures and errors,
+  # which also contains the first 3 lines of the backtrace for each.
+  class Reports::Progress < Report
+    # Set the stream where the report will be written to. STDOUT by default.
+    def initialize(stream=STDOUT)
+      @stream = stream
+    end
+
+    on :end do |report|
+      report.instance_eval do
+        puts
+        puts
+        report_pending_tests unless pendings.empty?
+        report_errors unless errors.empty?
+        puts summary
+        puts running_time
+      end
+    end
+
+    on :pass do |report, pass|
+      report.send(:print, ".")
+    end
+
+    on :pending do |report, pending|
+      report.send(:print, "P")
+    end
+
+    on :failure do |report, failure|
+      report.send(:print, "F")
+    end
+
+    on :error do |report, error|
+      report.send(:print, "E")
+    end
+
+    private
+
+      def running_time
+        "Ran in #{time_elapsed} seconds"
+      end
+
+      def report_pending_tests
+        puts "Pending tests:"
+        puts
+
+        pad_indexes = pendings.size.to_s.size
+        pendings.each_with_index do |pending, index|
+          puts "  #{pad(index+1, pad_indexes)}) #{pending.test_name} (#{pending.pending_message})"
+          puts indent("On line #{pending.line} of `#{pending.file}'", 6 + pad_indexes)
+          puts
+        end
+      end
+
+      def report_errors
+        puts "Failures:"
+        puts
+
+        pad_indexes = failures_and_errors.size.to_s.size
+        failures_and_errors.each_with_index do |error, index|
+          puts "  #{pad(index+1, pad_indexes)}) #{test_type(error)}: `#{error.test_name}' (on line #{error.line} of `#{error.file}')"
+          puts indent("With `#{error.error_message}'", 6 + pad_indexes)
+          puts indent(error.backtrace[0..2].join("\n"), 6 + pad_indexes)
+          puts
+        end
+      end
+
+      def summary
+        "%d test%s, %d assertion%s (%d passed, %d pending, %d failed, %d errored)" % [total_tests,
+                                                                                      total_tests == 1 ? "" : "s",
+                                                                                      assertions,
+                                                                                      assertions == 1 ? "" : "s",
+                                                                                      passes.size,
+                                                                                      pendings.size,
+                                                                                      failures.size,
+                                                                                      errors.size]
+      end
+
+      def indent(strings, size=2, indent_with=" ")
+        Array(strings).map do |str|
+          str.to_s.split("\n").map {|s| indent_with * size + s }.join("\n")
+        end
+      end
+
+      def pad(str, amount)
+        " " * (amount - str.to_s.size) + str.to_s
+      end
+
+      def test_type(test)
+        case test # order is important since ErroredTest < FailedTest
+        when ErroredTest; "Error"
+        when FailedTest;  "Failure"
+        end
+      end
+
+      def print(*args)
+        @stream.print(*args)
+      end
+
+      def puts(*args)
+        @stream.puts(*args)
+      end
+  end
+
+  add_report :progress, Reports::Progress
+end

data/lib/testicles/runner.rb

@@ -0,0 +1,24 @@
+module Testicles
+  class Runner
+    # Set up the test runner. Takes in a Report that will be passed to test
+    # cases for reporting.
+    def initialize(report)
+      @report = report
+    end
+
+    # Run a set of test cases, provided as arguments. This will fire relevant
+    # events on the runner's report, at the +start+ and +end+ of the test run,
+    # and before and after each test case (+enter+ and +exit+.)
+    def run(*test_cases)
+      @report.on_start if @report.respond_to?(:on_start)
+      started_at = Time.now
+      test_cases.each do |test_case|
+        @report.on_enter(test_case) if @report.respond_to?(:on_enter)
+        test_case.run(@report)
+        @report.on_exit(test_case) if @report.respond_to?(:on_exit)
+      end
+      @report.time_elapsed = Time.now - started_at
+      @report.on_end if @report.respond_to?(:on_end)
+    end
+  end
+end

data/lib/testicles/test_case.rb

@@ -0,0 +1,185 @@
+module Testicles
+  class TestCase
+    # Run all tests in this context. Takes a Report instance in order to
+    # provide output.
+    def self.run(result)
+      result.report("#{description} global setup", false) { do_global_setup }
+      tests.each {|test| test.run(result) }
+      result.report("#{description} global teardown", false) { do_global_teardown }
+    end
+
+    # Add a test to be run in this context. This method is aliased as +it+ and
+    # +should+ for your comfort.
+    def self.test(name, &block)
+      tests << new(name, &block)
+    end
+
+    # Add a setup block to be run before each test in this context. This method
+    # is aliased as +before+ for your comfort.
+    def self.setup(&block)
+      define_method :setup do
+        super
+        instance_eval(&block)
+      end
+    end
+
+    # Add a +setup+ block that will be run *once* for the entire test case,
+    # before the first test is run.
+    #
+    # Keep in mind that while +setup+ blocks are evaluated on the context of the
+    # test, and thus you can share state between them, your tests will not be
+    # able to access instance variables set in a +global_setup+ block.
+    #
+    # This is usually not needed (and generally using it is a code smell, since
+    # you could make a test dependent on the state of other tests, which is a
+    # huge problem), but it comes in handy when you need to do expensive
+    # operations in your test setup/teardown and the tests won't modify the
+    # state set on this operations. For example, creating large amount of
+    # records in a database or filesystem, when your tests will only read these
+    # records.
+    def self.global_setup(&block)
+      (class << self; self; end).class_eval do
+        define_method :do_global_setup do
+          super
+          instance_eval(&block)
+        end
+      end
+    end
+
+    # Add a teardown block to be run after each test in this context. This
+    # method is aliased as +after+ for your comfort.
+    def self.teardown(&block)
+      define_method :teardown do
+        instance_eval(&block)
+        super
+      end
+    end
+
+    # Add a +teardown+ block that will be run *once* for the entire test case,
+    # after the last test is run.
+    #
+    # Keep in mind that while +teardown+ blocks are evaluated on the context of
+    # the test, and thus you can share state between the tests and the
+    # teardown blocks, you will not be able to access instance variables set in
+    # a test from your +global_teardown+ block.
+    #
+    # See TestCase.global_setup for a discussion on why these methods are best
+    # avoided unless you really need them and use them carefully.
+    def self.global_teardown(&block)
+      (class << self; self; end).class_eval do
+        define_method :do_global_teardown do
+          instance_eval(&block)
+          super
+        end
+      end
+    end
+
+
+    # Define a new test context nested under the current one. All +setup+ and
+    # +teardown+ blocks defined on the current context will be inherited by the
+    # new context. This method is aliased as +describe+ for your comfort.
+    def self.context(description, &block)
+      subclass = Class.new(self)
+      subclass.class_eval(&block) if block
+      subclass.description = "#{self.description} #{description}".strip
+      const_set(sanitize_description(description), subclass)
+    end
+
+    class << self
+      # Fancy name for your test case, reports can use this to give nice,
+      # descriptive output when running your tests.
+      attr_accessor :description
+
+      alias_method :describe,   :context
+      alias_method :story,      :context
+
+      alias_method :before,     :setup
+      alias_method :after,      :teardown
+
+      alias_method :before_all, :global_setup
+      alias_method :after_all,  :global_setup
+
+      alias_method :it,         :test
+      alias_method :should,     :test
+      alias_method :scenario,   :test
+    end
+
+    # Initialize a new instance of a single test. This test can be run in
+    # isolation by calling TestCase#run.
+    def initialize(name, &block)
+      @test = block
+      @name = name
+    end
+
+    # Run a test in isolation. Any +setup+ and +teardown+ blocks defined for
+    # this test case will be run as expected.
+    #
+    # You need to provide a Report instance to handle errors/pending tests/etc.
+    #
+    # If the test's block is nil, then the test will be marked as pending and
+    # nothing will be run.
+    def run(result)
+      @result = result
+
+      result.report(name) do
+        pending if test.nil?
+
+        setup
+        instance_eval(&test)
+        teardown
+      end
+    end
+
+    # Ensure a condition is met. This will raise AssertionFailed if the
+    # condition isn't met. You can override the default failure message
+    # by passing it as an argument.
+    def assert(condition, message="Expected condition to be satisfied")
+      @result.on_assertion
+      raise AssertionFailed, message unless condition
+    end
+
+    # Make the test be ignored as pending. You can override the default message
+    # that will be sent to the report by passing it as an argument.
+    def pending(message="Not Yet Implemented")
+      raise Pending, message
+    end
+
+    private
+
+    def setup #:nodoc:
+    end
+
+    def teardown #:nodoc:
+    end
+
+    def test
+      @test
+    end
+
+    def name
+      @name
+    end
+
+    def self.tests
+      @tests ||= []
+    end
+    private_class_method :tests
+
+    def self.sanitize_description(description)
+      "Test#{description.gsub(/\W+/, ' ').strip.gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+    end
+    private_class_method :sanitize_description
+
+    def self.do_global_setup
+    end
+    private_class_method :do_global_setup
+
+    def self.do_global_teardown
+    end
+    private_class_method :do_global_teardown
+
+    def self.inherited(child)
+      Testicles.add_test_case(child)
+    end
+  end
+end

data/testicles.gemspec

@@ -0,0 +1,31 @@
+Gem::Specification.new do |s|
+  s.name    = "testicles"
+  s.version = "0.1"
+  s.date    = "2009-09-11"
+
+  s.description = "Testicles is a tiny, simple, and easy-to-extend test framework"
+  s.summary     = s.description
+  s.homepage    = "http://github.com/foca/testicles"
+
+  s.authors = ["Nicolás Sanguinetti"]
+  s.email   = "contacto@nicolassanguinetti.info"
+
+  s.require_paths     = ["lib"]
+  s.rubyforge_project = "testicles"
+  s.has_rdoc          = true
+  s.rubygems_version  = "1.3.1"
+
+  s.files = %w[
+.gitignore
+LICENSE
+README.rdoc
+Rakefile
+testicles.gemspec
+lib/testicles.rb
+lib/testicles/test_case.rb
+lib/testicles/runner.rb
+lib/testicles/report.rb
+lib/testicles/reports.rb
+lib/testicles/reports/progress.rb
+]
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: testicles
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- "Nicol\xC3\xA1s Sanguinetti"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-11 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: Testicles is a tiny, simple, and easy-to-extend test framework
+email: contacto@nicolassanguinetti.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- testicles.gemspec
+- lib/testicles.rb
+- lib/testicles/test_case.rb
+- lib/testicles/runner.rb
+- lib/testicles/report.rb
+- lib/testicles/reports.rb
+- lib/testicles/reports/progress.rb
+has_rdoc: true
+homepage: http://github.com/foca/testicles
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: testicles
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: Testicles is a tiny, simple, and easy-to-extend test framework
+test_files: []
+