hardmock 1.2.0 → 1.2.3

data/test/functional/auto_verify_test.rb

@@ -11,72 +11,6 @@ class AutoVerifyTest < Test::Unit::TestCase
     remove_temp_test_file
   end
 
-  #
-  # HELPERS
-  #
-
-  def temp_test_file
-    File.expand_path(File.dirname(__FILE__) + "/tear_down_verification_test.rb")
-  end
-
-  def run_test(tbody)
-    File.open(temp_test_file,"w") { |f| f.print(tbody) }
-    @test_output = `ruby #{temp_test_file} 2>&1`
-#    puts "------------------------"
-#    puts @test_output
-#    puts "------------------------"
-  end
-
-  def remove_temp_test_file
-    FileUtils::rm_f temp_test_file
-  end
-
-  def assert_results(h)
-    assert_match(/#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/,
-     @test_output)
-  end
-
-  def assert_output_contains(*patterns)
-    patterns.each do |pattern|
-      assert_match(pattern,@test_output)
-    end
-  end
-  
-  def assert_output_doesnt_contain(*patterns)
-    patterns.each do |pattern|
-      assert @test_output !~ pattern, "Output shouldn't match #{pattern.inspect} but it does."
-    end
-  end
-
-  def write_and_execute_test
-    @test_code ||=<<-EOM
-        def test_setup_doomed_expectation
-          create_mock :automobile
-          @automobile.expects.start
-        end
-    EOM
-    @full_code ||=<<-EOTEST
-      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-      require 'hardmock'
-      class DummyTest < Test::Unit::TestCase
-        #{@teardown_code}
-        #{@test_code}
-      end 
-    EOTEST
-    run_test @full_code
-
-    if @expect_unmet_expectations 
-      assert_output_contains(/unmet expectations/i, /automobile/, /start/)
-    else
-      assert_output_doesnt_contain(/unmet expectations/i, /automobile/, /start/)
-    end
-
-    @expect_tests ||= 1
-    @expect_failures ||= 0
-    @expect_errors ||= 1
-    assert_results :tests => @expect_tests, :failures => @expect_failures, :errors => @expect_errors
-  end
-  
   #
   # TESTS
   #
@@ -189,4 +123,71 @@ class AutoVerifyTest < Test::Unit::TestCase
     write_and_execute_test
     assert_output_contains(/Test helper teardown/, /User teardown/)
   end
+
+  #
+  # HELPERS
+  #
+
+  def temp_test_file
+    File.expand_path(File.dirname(__FILE__) + "/tear_down_verification_test.rb")
+  end
+
+  def run_test(tbody)
+    File.open(temp_test_file,"w") { |f| f.print(tbody) }
+    @test_output = `ruby #{temp_test_file} 2>&1`
+#    puts "------------------------"
+#    puts @test_output
+#    puts "------------------------"
+  end
+
+  def remove_temp_test_file
+    FileUtils::rm_f temp_test_file
+  end
+
+  def assert_results(h)
+    assert_match(/#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/,
+     @test_output)
+  end
+
+  def assert_output_contains(*patterns)
+    patterns.each do |pattern|
+      assert_match(pattern,@test_output)
+    end
+  end
+  
+  def assert_output_doesnt_contain(*patterns)
+    patterns.each do |pattern|
+      assert @test_output !~ pattern, "Output shouldn't match #{pattern.inspect} but it does."
+    end
+  end
+
+  def write_and_execute_test
+    @test_code ||=<<-EOM
+        def test_setup_doomed_expectation
+          create_mock :automobile
+          @automobile.expects.start
+        end
+    EOM
+    @full_code ||=<<-EOTEST
+      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+      require 'hardmock'
+      class DummyTest < Test::Unit::TestCase
+        #{@teardown_code}
+        #{@test_code}
+      end 
+    EOTEST
+    run_test @full_code
+
+    if @expect_unmet_expectations 
+      assert_output_contains(/unmet expectations/i, /automobile/, /start/)
+    else
+      assert_output_doesnt_contain(/unmet expectations/i, /automobile/, /start/)
+    end
+
+    @expect_tests ||= 1
+    @expect_failures ||= 0
+    @expect_errors ||= 1
+    assert_results :tests => @expect_tests, :failures => @expect_failures, :errors => @expect_errors
+  end
+  
 end

data/test/functional/hardmock_test.rb

@@ -1,5 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
 require 'hardmock'
+require 'assert_error'
+
 class HardmockTest < Test::Unit::TestCase
 
   def setup
@@ -351,8 +353,8 @@ class HardmockTest < Test::Unit::TestCase
 		assert_equal false, @car.ignition_on?, "Should be false"
 	end
 
-  def test_should_be_able_to_mock_methods_inherited_from_object
-    target_methods = %w|to_s instance_eval instance_variables id clone display dup eql? ==|
+  def test_should_be_able_to_mock_some_methods_inherited_from_object
+    target_methods = %w|id clone display dup eql? ==|
     create_mock :foo
     target_methods.each do |m|
       eval %{@foo.expects(m, "some stuff")}
@@ -360,12 +362,56 @@ class HardmockTest < Test::Unit::TestCase
     end
   end
 
-  def test_should_support_expect_and_should_receive_as_aliases_for_expects 
+  def test_should_support_expect_as_an_alias_for_expects 
     create_mock :foo
     @foo.expect.boomboom
     @foo.boomboom
     verify_mocks 
   end
 
+  def test_should_not_raise_expectation_errors_for_some_methods_defined_on_object
+    create_mock :foo
+    @foo.method(:inspect)
+    @foo.inspect
+    @foo.to_s
+    @foo.instance_variables
+    @foo.instance_eval("")
+    verify_mocks 
+  end
+
+  def test_should_support_raising_errors_within_expectation_blocks
+    create_mock :cat
+    @cat.expects.meow do |arg|
+      assert_equal "mix", arg
+      raise 'HAIRBALL'
+    end
+    assert_error RuntimeError, 'HAIRBALL' do 
+      @cat.meow("mix")
+    end
+  end
+
+  def test_should_support_raising_errors_after_expectation_blocks
+    create_mock :cat
+    @cat.expects.meow do |arg|
+      assert_equal "mix", arg
+    end.raises('HAIRBALL')
+    assert_error RuntimeError, 'HAIRBALL' do 
+      @cat.meow("mix")
+    end
+  end
+
+  def test_should_raise_when_create_mocks_is_given_a_nil_name
+    # I make this mistake all the time: Typing in an instance var name instead of a symbol in create_mocks.
+    # When you do that, you're effectively passing nil(s) in as mock names.
+    assert_error ArgumentError, /'nil' is not a valid name for a mock/ do
+      create_mocks @apples, @oranges
+    end
+  end
+
+  def test_should_display_mock_name_in_inspect_output
+    create_mock :hay_bailer
+    assert_equal "<Mock hay_bailer>", @hay_bailer.inspect, "Wrong output from 'inspect'"
+  end
+
 end
 

data/test/unit/expectation_builder_test.rb

@@ -1,14 +1,15 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/expectation_builder'
 
 class ExpectationBuilderTest < Test::Unit::TestCase
+  include Hardmock
   
   def test_build_expectation
     builder = ExpectationBuilder.new
     
     ex = builder.build_expectation( :stuff => 'inside' )
     assert_not_nil ex, "Didn't build an expectation"
-    assert_kind_of SimpleExpectation, ex, "Wrong type!"
+    assert_kind_of Expectation, ex, "Wrong type!"
 
     # Shhhh... fragile, yes, whatever.  The functional tests do the 
     # real testing of this anyway

data/test/unit/{simple_expectation_test.rb → expectation_test.rb}

@@ -1,7 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/expectation'
+require 'hardmock/errors'
 
-class SimpleExpectationTest < Test::Unit::TestCase
+class ExpectationTest < Test::Unit::TestCase
+  include Hardmock
 
   def setup
     @mock = TheMock.new
@@ -22,12 +24,12 @@ class SimpleExpectationTest < Test::Unit::TestCase
   #
 
   def test_to_s
-    ex = SimpleExpectation.new( :mock => @mock, :method => 'a_func', :arguments => [1, "two", :three, { :four => 4 }] )  
+    ex = Expectation.new( :mock => @mock, :method => 'a_func', :arguments => [1, "two", :three, { :four => 4 }] )  
     assert_equal %|the_mock.a_func(1, "two", :three, {:four=>4})|, ex.to_s
   end
    
   def test_apply_method_call
-    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+    se = Expectation.new(:mock => @mock, :method => 'some_func',
       :arguments => [1,'two',:three] )
 
     # Try it good:
@@ -68,7 +70,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
     # now with a proc
     thinger = nil
     the_proc = Proc.new { thinger = :shaq }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+    se = Expectation.new(:mock => @mock, :method => 'some_func',
       :block => the_proc)
 
     # Try it good:
@@ -88,7 +90,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
       passed_block = blk 
     }
 
-    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :block => exp_block,
+    se = Expectation.new(:mock => @mock, :method => 'some_func', :block => exp_block,
       :arguments => [])
 
     set_flag = false
@@ -109,7 +111,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_apply_method_call_fails_when_theres_no_expectation_block_to_handle_the_runtime_block
-    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :arguments => [])
+    se = Expectation.new(:mock => @mock, :method => 'some_func', :arguments => [])
     runtime_block = Proc.new { set_flag = true }
     err = assert_raise ExpectationError do
       se.apply_method_call( @mock, 'some_func', [], runtime_block)
@@ -119,7 +121,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_returns
-    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+    se = Expectation.new(:mock => @mock, :method => 'some_func',
       :arguments => [1,'two',:three])
 
     se.returns "A value"
@@ -129,7 +131,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
 
   def test_apply_method_call_captures_block_value
     the_proc = lambda { "in the block" }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
 
     assert_nil se.block_value, "Block value starts out nil"
     
@@ -143,7 +145,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
     target = false
     inner_proc = lambda { target = true }
     the_proc = lambda { inner_proc }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
 
     assert_nil se.block_value, "Block value starts out nil"
     se.apply_method_call(@mock, 'do_it', [], nil)
@@ -159,7 +161,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
     target = nil
     inner_proc = lambda { |one,two| target = [one,two] }
     the_proc = lambda { inner_proc }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
 
     assert_nil se.block_value, "Block value starts out nil"
     se.apply_method_call(@mock, 'do_it', [], nil)
@@ -171,7 +173,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_trigger_nil_block_value
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [])
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [])
 
     assert_nil se.block_value, "Block value starts out nil"
     se.apply_method_call(@mock, 'do_it', [], nil)
@@ -186,7 +188,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
 
   def test_trigger_non_proc_block_value
     the_block = lambda { "woops" }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_block)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_block)
 
     se.apply_method_call(@mock, 'do_it', [], nil)
     assert_equal "woops", se.block_value
@@ -203,7 +205,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
 
   def test_proc_used_for_return
     the_proc = lambda { "in the block" }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
 
     assert_equal "in the block", se.apply_method_call(@mock, 'do_it', [], nil)
     assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
@@ -211,14 +213,14 @@ class SimpleExpectationTest < Test::Unit::TestCase
 
   def test_explicit_return_overrides_proc_return
     the_proc = lambda { "in the block" }
-    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se = Expectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
     se.returns "the override"
     assert_equal "the override", se.apply_method_call(@mock, 'do_it', [], nil)
     assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
   end
 
   def test_yields
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields :bean1, :bean2
 
     things = []
@@ -229,7 +231,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_block_takes_no_arguments
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields
 
     things = []
@@ -239,7 +241,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_params_to_block_takes_no_arguments
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields :wont_fit
 
     things = []
@@ -254,7 +256,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_with_returns
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] ,
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] ,
       :returns => 'the results')
     
     exp = se.yields :bean1, :bean2
@@ -267,7 +269,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_with_raises
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot],
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot],
       :raises => RuntimeError.new("kerboom"))
     
     exp = se.yields :bean1, :bean2
@@ -282,7 +284,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_and_inner_block_explodes
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot])
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot])
     
     exp = se.yields :bean1, :bean2
     assert_same se, exp, "'yields' needs to return a reference to the expectation"
@@ -299,7 +301,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_with_several_arrays
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields ['a','b'], ['c','d']
 
     things = []
@@ -310,7 +312,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_tuples
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields ['a','b','c'], ['d','e','f']
 
     things = []
@@ -326,7 +328,7 @@ class SimpleExpectationTest < Test::Unit::TestCase
   end
 
   def test_yields_tuples_size_mismatch
-    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se = Expectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
     se.yields ['a','b','c'], ['d','e','f']
 
     things = []

data/test/unit/expector_test.rb

@@ -1,7 +1,8 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/expector'
 
 class ExpectorTest < Test::Unit::TestCase
+  include Hardmock
 
   class MyControl
     attr_reader :added
@@ -19,19 +20,6 @@ class ExpectorTest < Test::Unit::TestCase
     end
   end
 
-  #
-  # TESTS
-  #
-
-  def test_method_missing
-    try_it_with 'wonder_bread'
-    try_it_with 'whatever'
-  end
-
-  def test_methods_that_wont_trigger_method_missing
-    try_it_with 'instance_eval'
-  end
-
   def try_it_with(method_name)
     mock = Object.new
     mock_control = MyControl.new
@@ -50,5 +38,20 @@ class ExpectorTest < Test::Unit::TestCase
     assert_equal "dummy expectation", output, "Expectation should have been returned"
   end
 
+  #
+  # TESTS
+  #
+  def test_method_missing
+    try_it_with 'wonder_bread'
+    try_it_with 'whatever'
+  end
+
+  def test_methods_that_wont_trigger_method_missing
+    mock = Object.new
+    mock_control = MyControl.new
+    builder = ExpBuilder.new
 
+    exp = Expector.new(mock, mock_control, builder)
+    assert_equal mock, exp.instance_eval("@mock")
+  end
 end

data/test/unit/method_cleanout_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'method_cleanout'
+require 'hardmock/method_cleanout'
 
 class MethodCleanoutTest < Test::Unit::TestCase
   class Victim
@@ -27,7 +27,7 @@ class MethodCleanoutTest < Test::Unit::TestCase
   end
 
   def test_should_include_certain_important_methods_in_the_sacred_methods_list
-    %w|__id__ __send__ send equal? respond_to? nil?|.each do |m|
+    %w|__id__ __send__ equal? object_id send nil? class kind_of? respond_to? inspect method to_s instance_variables instance_eval|.each do |m|
       assert Hardmock::MethodCleanout::SACRED_METHODS.include?(m), "important method #{m} is not included in SACRED_METHODS"
     end
   end

data/test/unit/mock_control_test.rb

@@ -1,7 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/utils'
+require 'hardmock/errors'
+require 'hardmock/mock_control'
 
 class MockControlTest < Test::Unit::TestCase
+  include Hardmock
 
   def setup
     @unmock = OpenStruct.new( :_name => 'fakemock' )

data/test/unit/mock_test.rb

@@ -1,7 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/method_cleanout'
+require 'hardmock/mock'
+require 'hardmock/mock_control'
+require 'hardmock/expectation_builder'
+require 'hardmock/expector'
+require 'hardmock/trapper'
 
 class MockTest < Test::Unit::TestCase
+  include Hardmock
 
   def test_build_with_control
     mc1 = MockControl.new
@@ -270,6 +276,4 @@ class MockTest < Test::Unit::TestCase
     mock._verify
   end
 
-
-
 end

data/test/unit/trapper_test.rb

@@ -1,7 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/method_cleanout'
+require 'hardmock/trapper'
 
 class TrapperTest < Test::Unit::TestCase
+  include Hardmock
 
   def setup
     @mock = Object.new

data/test/unit/verify_error_test.rb

@@ -1,7 +1,13 @@
 require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock'
+require 'hardmock/method_cleanout'
+require 'hardmock/mock_control'
+require 'hardmock/errors'
+require 'hardmock/expectation_builder'
+require 'hardmock/expectation'
+require 'hardmock/mock'
 
 class VerifyErrorTest < Test::Unit::TestCase
+  include Hardmock
 
   #
   # TESTS
@@ -10,8 +16,8 @@ class VerifyErrorTest < Test::Unit::TestCase
   def test_formatted_list_of_unmet_expectations
     mock1 = Mock.new('mock1')
     mock2 = Mock.new('mock2')
-    exp1 = SimpleExpectation.new( :mock => mock1, :method => 'send_parts', :arguments => [1,2,:a] )
-    exp2 = SimpleExpectation.new( :mock => mock2, :method => 'grind_it', :arguments => [] )
+    exp1 = Expectation.new( :mock => mock1, :method => 'send_parts', :arguments => [1,2,:a] )
+    exp2 = Expectation.new( :mock => mock2, :method => 'grind_it', :arguments => [] )
 
     exp_list = [ exp1, exp2 ]
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: hardmock
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
-date: 2006-12-19 00:00:00 -05:00
+  version: 1.2.3
+date: 2007-04-28 00:00:00 -04:00
 summary: A strict, ordered, expectation-oriented mock object library.
 require_paths: 
 - lib
@@ -29,36 +29,49 @@ post_install_message:
 authors: 
 - David Crosby
 files: 
+- lib/assert_error.rb
 - lib/hardmock.rb
-- lib/method_cleanout.rb
+- lib/hardmock/errors.rb
+- lib/hardmock/expectation.rb
+- lib/hardmock/expectation_builder.rb
+- lib/hardmock/expector.rb
+- lib/hardmock/method_cleanout.rb
+- lib/hardmock/mock.rb
+- lib/hardmock/mock_control.rb
+- lib/hardmock/trapper.rb
+- lib/hardmock/utils.rb
+- lib/tasks/rdoc_options.rb
 - test/test_helper.rb
 - test/functional/assert_error_test.rb
 - test/functional/auto_verify_test.rb
 - test/functional/direct_mock_usage_test.rb
 - test/functional/hardmock_test.rb
 - test/unit/expectation_builder_test.rb
+- test/unit/expectation_test.rb
 - test/unit/expector_test.rb
 - test/unit/method_cleanout_test.rb
 - test/unit/mock_control_test.rb
 - test/unit/mock_test.rb
-- test/unit/simple_expectation_test.rb
 - test/unit/trapper_test.rb
 - test/unit/verify_error_test.rb
-- CHANGES
-- LICENSE
 - Rakefile
+- config/environment.rb
+- lib/tasks/rdoc.rake
+- lib/tasks/test.rake
 - README
+- CHANGES
+- LICENSE
 test_files: 
 - test/functional/assert_error_test.rb
 - test/functional/auto_verify_test.rb
 - test/functional/direct_mock_usage_test.rb
 - test/functional/hardmock_test.rb
 - test/unit/expectation_builder_test.rb
+- test/unit/expectation_test.rb
 - test/unit/expector_test.rb
 - test/unit/method_cleanout_test.rb
 - test/unit/mock_control_test.rb
 - test/unit/mock_test.rb
-- test/unit/simple_expectation_test.rb
 - test/unit/trapper_test.rb
 - test/unit/verify_error_test.rb
 rdoc_options: