mofo 0.2.2 → 0.2.3

data/vendor/testspec-0.3.0/lib/test/spec/dox.rb

@@ -1,122 +0,0 @@
-require 'test/unit/ui/console/testrunner'
-
-module Test::Unit::UI           # :nodoc:
-  module SpecDox                # :nodoc:
-    class TestRunner < Test::Unit::UI::Console::TestRunner
-      protected
-      def setup_mediator
-        @mediator = create_mediator(@suite)
-      end
-
-      def add_fault(fault)
-        if fault.kind_of? Test::Spec::Disabled
-          @disabled += 1
-          output_no_nl " (disabled)"
-        else
-          @faults << fault
-          word = fault.class.name[/(.*::)?(.*)/, 2].upcase
-          output_no_nl " (#{word} - #{@faults.size})"
-        end
-      end
-      
-      def started(result)
-        @result = result
-        @context = nil
-        @contexts = []
-        @disabled = 0
-        indent 0
-      end
-      
-      def finished(elapsed_time)
-        nl
-        output "Finished in #{elapsed_time} seconds."
-        @faults.each_with_index do |fault, index|
-          nl
-          output("%3d) %s" % [index + 1, fault.long_display])
-        end
-        nl
-        output_result
-      end
-
-      def output_result
-        if @disabled > 0
-          disabled = ", #{@disabled} disabled"
-        else
-          disabled = ""
-        end
-
-        r = "%d specifications#{disabled} (%d requirements), %d failures" % [
-          @result.run_count, @result.assertion_count, @result.failure_count]
-        r << ", #{@result.error_count} errors"  if @result.error_count > 0
-        output r
-      end
-      
-      def test_started(name)
-        contextname, specname = unmangle name
-        return  if contextname.nil? || specname.nil?
-
-        if @context != contextname
-          @context = contextname
-
-          @old_contexts = @contexts
-          @contexts = @context.split("\t")
-
-          common = 0
-          @contexts.zip(@old_contexts) { |a, b|
-            break  if a != b
-            common += 1
-          }
-
-          nl  if common == 0
-
-          @contexts[common..-1].each_with_index { |head, i|
-            indent common + i
-            output_heading head
-          }
-        end
-        
-        output_item specname
-      end
-      
-      def test_finished(name)
-        # Don't let empty contexts clutter up the output.
-        nl  unless name =~ /\Adefault_test\(/
-      end
-
-      def output_no_nl(something, level=NORMAL)
-        @io.write(something) if (output?(level))
-        @io.flush
-      end
-
-      def output_item(item)
-        output_no_nl "#{@prefix}- #{item}"
-      end
-
-      def output_heading(heading)
-        output "#{@prefix}#{heading}"
-      end
-
-      def unmangle(name)
-        if name =~ /\Atest_spec \{(.*?)\} \d+ \[(.*)\]/
-          contextname = $1
-          specname = $2
-        elsif name =~ /test_(.*?)\((.*)\)$/
-          specname = $1
-          contextname = $2
-
-          contextname.gsub!(/^Test\B|\BTest$/, '')
-          specname.gsub!(/_/, ' ')
-        else
-          contextname = specname = nil
-        end
-
-        [contextname, specname]
-      end
-
-      def indent(depth)
-        @indent = depth
-        @prefix = "  " * depth
-      end
-    end
-  end
-end

data/vendor/testspec-0.3.0/lib/test/spec/rdox.rb

@@ -1,25 +0,0 @@
-require 'test/spec/dox'
-
-module Test::Unit::UI           # :nodoc:
-  module RDox                   # :nodoc:
-    class TestRunner < Test::Unit::UI::SpecDox::TestRunner
-      def output_heading(heading)
-        output "#{@headprefix} #{heading}"
-      end
-      
-      def output_item(item)
-        output_no_nl "* #{item}"
-      end
-      
-      def finished(elapsed_time)
-        nl
-        output_result
-      end
-
-      def indent(depth)
-        @prefix = ""
-        @headprefix = "==" + "=" * depth
-      end
-    end
-  end
-end

data/vendor/testspec-0.3.0/lib/test/spec/should-output.rb

@@ -1,49 +0,0 @@
-# Code adapted from rs, written by Eero Saynatkari.
-require 'fileutils'
-require 'tmpdir'
-
-class Test::Spec::Should
-  # Captures output from the IO given as
-  # the second argument (STDIN by default)
-  # and matches it against a String or 
-  # Regexp given as the first argument.
-  def output(expected, to = STDOUT)
-    # Store the old stream
-    old_to = to.dup
-
-    # Obtain a filehandle to replace (works with Readline)
-    to.reopen File.open(File.join(Dir.tmpdir, "should_output_#{$$}"), "w+")
-    
-    # Execute
-    @object.call
-
-    # Restore
-    out = to.dup
-    to.reopen old_to
-
-    # Grab the data
-    out.rewind
-    output = out.read
-
-    # Match up
-    case expected
-      when Regexp
-        output.should.match expected
-      else
-        output.should.equal expected
-    end                               # case expected
-
-  # Clean up
-  ensure
-    out.close
-
-    # STDIO redirection will break else
-    begin
-      to.seek 0, IO::SEEK_END
-    rescue Errno::ESPIPE
-    rescue Errno::EPIPE
-    end
-
-    FileUtils.rm_f out.path
-  end                                 # output
-end                                   # Test::Spec::Should

data/vendor/testspec-0.3.0/test/spec_dox.rb

@@ -1,39 +0,0 @@
-require 'test/spec'
-
-require 'test/spec/dox'
-
-context "SpecDox" do
-  setup do
-    r = Test::Unit::UI::SpecDox::TestRunner.new(nil)
-    @unmangler = r.method(:unmangle)
-  end
-  
-  specify "can unmangle Test::Unit names correctly" do
-    @unmangler["test_foo_bar(TestFoo)"].should.equal ["Foo", "foo bar"]
-    @unmangler["test_foo_bar(FooTest)"].should.equal ["Foo", "foo bar"]
-    @unmangler["test_he_he(Foo)"].should.equal ["Foo", "he he"]
-    @unmangler["test_heh(Foo)"].should.equal ["Foo", "heh"]
-
-    @unmangler["test_heh(Test::Unit::TC_Assertions)"].
-      should.equal ["Test::Unit::TC_Assertions", "heh"]
-
-    @unmangler["test_heh(Foo::Bar::Test)"].
-      should.equal ["Foo::Bar::Test", "heh"]
-  end
-
-  specify "can unmangle Test::Spec names correctly" do
-    @unmangler["test_spec {context} 007 [whee]()"].
-      should.equal ["context", "whee"]
-    @unmangler["test_spec {a bit longish context} 069 [and more text]()"].
-      should.equal ["a bit longish context", "and more text"]
-    @unmangler["test_spec {special chars !\"/&%$} 2 [special chars !\"/&%$]()"].
-      should.equal ["special chars !\"/&%$", "special chars !\"/&%$"]
-    @unmangler["test_spec {[]} 666666 [{}]()"].
-      should.equal ["[]", "{}"]
-  end
-
-  specify "has sensible fallbacks" do
-    @unmangler["weird"].should.equal [nil, nil]
-  end
-end
-  

data/vendor/testspec-0.3.0/test/spec_flexmock.rb

@@ -1,210 +0,0 @@
-# Adapted from flexmock (http://onestepback.org/software/flexmock).
-#
-# Copyright 2006 by Jim Weirich (jweirich@one.net).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-
-
-require 'test/spec'
-
-begin
-  require 'flexmock'
-rescue LoadError
-  context "flexmock" do
-    specify "can not be found.  BAIL OUT!" do
-    end
-  end
-else
-
-context "flexmock" do
-  setup do
-    @mock = FlexMock.new
-  end
-
-  specify "should handle" do
-    args = nil
-    @mock.mock_handle(:hi) { |a, b| args = [a,b] }
-    @mock.hi(1,2)
-    args.should.equal [1,2]
-  end
-
-  specify "should handle without a block" do
-    lambda {
-      @mock.mock_handle(:blip)
-      @mock.blip
-    }.should.not.raise
-  end
-
-  specify "should handle with a block" do
-    called = false
-    @mock.mock_handle(:blip) { |block| block.call }
-    @mock.blip { called = true }
-    called.should.be true
-  end
-
-  specify "should have a return value" do
-    @mock.mock_handle(:blip) { 10 }
-    @mock.blip.should.equal 10
-  end
-
-  specify "should handle missing methods" do
-    ex = lambda {
-      @mock.not_defined
-    }.should.raise(NoMethodError)
-    ex.message.should.match(/not_defined/)
-  end
-
-  specify "should ignore missing methods" do
-    lambda {
-      @mock.mock_ignore_missing
-      @mock.blip
-    }.should.not.raise
-  end
-
-  specify "should count correctly" do
-    @mock.mock_handle(:blip, 3)
-    @mock.blip
-    @mock.blip
-    @mock.blip
-    @mock.mock_verify
-  end
-
-  specify "should raise on bad counts" do
-    @mock.mock_handle(:blip, 3)
-    @mock.blip
-    @mock.blip
-    lambda { @mock.mock_verify }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should handle undetermined counts" do
-    FlexMock.use('fs') { |m|
-      m.mock_handle(:blip)
-      m.blip
-      m.blip
-      m.blip
-    }
-  end
-
-  specify "should handle zero counts" do
-    lambda {
-      FlexMock.use { |m|
-        m.mock_handle(:blip, 0)
-        m.blip
-      }
-    }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should have file IO with use" do
-    file = FlexMock.use do |m|
-      filedata = ["line 1", "line 2"]
-      m.mock_handle(:gets, 3) { filedata.shift }
-      count_lines(m).should.equal 2
-    end
-  end
-
-  def count_lines(stream)
-    result = 0
-    while line = stream.gets
-      result += 1
-    end
-    result    
-  end
-
-  specify "should have use" do
-    lambda {
-      FlexMock.use do |m|
-	m.mock_handle(:blip, 2)
-	m.blip
-      end
-    }.should.raise Test::Unit::AssertionFailedError
-  end
-
-  specify "should handle failures during use" do
-    ex = lambda {
-      FlexMock.use do |m|
-	m.mock_handle(:blip, 2)
-	xyz
-      end
-    }.should.raise NameError
-    ex.message.should.match(/undefined local variable or method/)
-  end
-
-  specify "should deal with sequential values" do
-    values = [1,4,9,16]
-    @mock.mock_handle(:get) { values.shift }
-    @mock.get.should.equal 1
-    @mock.get.should.equal 4
-    @mock.get.should.equal 9
-    @mock.get.should.equal 16
-  end
-  
-  specify "respond_to? should return false for non handled methods" do
-    @mock.should.not.respond_to :blah
-  end
-
-  specify "respond_to? should return true for explicit methods" do
-    @mock.mock_handle(:xyz)
-    @mock.should.respond_to :xyz
-  end
-
-  specify "respond_to? should return true when ignoring_missing" do
-    @mock.mock_ignore_missing
-    @mock.should.respond_to :yada
-  end
-  
-  specify "respond_to? should return true for missing_methods when should_ignore_missing" do
-    @mock.should_ignore_missing
-    @mock.should.respond_to :yada
-  end
-
-  specify "should raise error on unknown method proc" do
-    lambda {
-      @mock.method(:xyzzy)
-    }.should.raise NameError
-  end
-
-  specify "should return callable proc on method" do
-    got_it = false
-    @mock.mock_handle(:xyzzy) { got_it = true }
-    method_proc = @mock.method(:xyzzy)
-    method_proc.should.not.be.nil
-    method_proc.call
-    got_it.should.be true
-  end
-
-  specify "should return do nothing proc for missing methods" do
-    @mock.mock_ignore_missing
-    method_proc = @mock.method(:plugh)
-    method_proc.should.not.be.nil
-    lambda { method_proc.call }.should.not.raise
-  end
-end
-
-
-class TemperatureSampler
-  def initialize(sensor)
-    @sensor = sensor
-  end
-
-  def average_temp
-    total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
-    total / 3.0
-  end
-end
-
-context "flexmock" do
-  include FlexMock::TestCase
-
-  specify "works with test/spec" do
-    sensor = flexmock("temp")
-    sensor.should_receive(:read_temperature).times(3).and_return(10, 12, 14)
-
-    sampler = TemperatureSampler.new(sensor)
-    sampler.average_temp.should.equal 12
-  end
-end
-
-end                             # if not rescue LoadError