rspec 0.3.2 → 0.4.0

data/test/expectations_for_should_have_test.rb

@@ -0,0 +1,144 @@
+require 'test/unit'
+
+require 'collection_owner'
+require 'spec'
+
+class ExpectationsForShouldHaveTest < Test::Unit::TestCase
+
+  def setup
+    @owner = CollectionOwner.new
+  end
+
+  def set_length(number)
+    (1..number).each do |n|
+      @owner.add_to_collection_with_length_method(n.to_s)
+    end
+  end
+  
+  def set_size(number)
+    (1..number).each do |n|
+      @owner.add_to_collection_with_size_method(n.to_s)
+    end
+  end
+  
+  def test_should_have_should_pass_if_responds_to_length_and_has_correct_number
+    assert_nothing_raised do
+      set_length 3
+      @owner.should.have(3).items_in_collection_with_length_method   
+    end
+  end    
+  
+  def test_should_have_should_pass_if_responds_to_size_and_has_correct_number
+    assert_nothing_raised do
+      set_size 7
+      @owner.should.have(7).items_in_collection_with_size_method   
+    end
+  end    
+  
+  def test_should_have_should_fail_if_responds_to_length_and_has_wrong_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_length 12
+      @owner.should.have(17).items_in_collection_with_length_method   
+    end
+  end    
+  
+  def test_should_have_should_fail_if_responds_to_size_and_has_wrong_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_size 6
+      @owner.should.have(2).items_in_collection_with_size_method   
+    end
+  end    
+
+  # at.least w/ length
+
+  def test_should_have_at_least_should_pass_if_responds_to_length_and_has_exact_number
+    assert_nothing_raised do
+      set_length 1
+      @owner.should.have.at.least(1).items_in_collection_with_length_method   
+    end
+  end    
+
+  def test_should_have_at_least_should_pass_if_responds_to_length_and_has_higher_number
+    assert_nothing_raised do
+      set_length 2
+      @owner.should.have.at.least(1).items_in_collection_with_length_method   
+    end
+  end    
+
+  def test_should_have_at_least_should_fail_if_responds_to_length_and_has_lower_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_length 1
+      @owner.should.have.at.least(2).items_in_collection_with_length_method   
+    end
+  end    
+
+  # at.least w/ size
+
+  def test_should_have_at_least_should_pass_if_responds_to_size_and_has_exact_number
+    assert_nothing_raised do
+      set_size 1
+      @owner.should.have.at.least(1).items_in_collection_with_size_method   
+    end
+  end    
+
+  def test_should_have_at_least_should_pass_if_responds_to_size_and_has_higher_number
+    assert_nothing_raised do
+      set_size 2
+      @owner.should.have.at.least(1).items_in_collection_with_size_method   
+    end
+  end    
+
+  def test_should_have_at_least_should_fail_if_responds_to_size_and_has_lower_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_size 1
+      @owner.should.have.at.least(2).items_in_collection_with_size_method   
+    end
+  end    
+  
+  # at.most w/ length
+
+  def test_should_have_at_most_should_pass_if_responds_to_length_and_has_exact_number
+    assert_nothing_raised do
+      set_length 1
+      @owner.should.have.at.most(1).items_in_collection_with_length_method   
+    end
+  end    
+
+  def test_should_have_at_most_should_pass_if_responds_to_length_and_has_lower_number
+    assert_nothing_raised do
+      set_length 1
+      @owner.should.have.at.most(2).items_in_collection_with_length_method   
+    end
+  end    
+
+  def test_should_have_at_most_should_fail_if_responds_to_length_and_has_higher_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_length 2
+      @owner.should.have.at.most(1).items_in_collection_with_length_method   
+    end
+  end    
+
+  # at.most w/ size
+
+  def test_should_have_at_most_should_pass_if_responds_to_size_and_has_exact_number
+    assert_nothing_raised do
+      set_size 1
+      @owner.should.have.at.most(1).items_in_collection_with_size_method   
+    end
+  end    
+
+  def test_should_have_at_most_should_pass_if_responds_to_size_and_has_lower_number
+    assert_nothing_raised do
+      set_size 1
+      @owner.should.have.at.most(2).items_in_collection_with_size_method   
+    end
+  end    
+
+  def test_should_have_at_most_should_fail_if_responds_to_size_and_has_higher_number
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      set_size 2
+      @owner.should.have.at.most(1).items_in_collection_with_size_method   
+    end
+  end    
+
+end

data/test/expectations_test.rb

@@ -21,271 +21,300 @@ class ExpectationsTest < Test::Unit::TestCase
     @nil_var = nil
   end
 
-  # should
+  # should.satisfy
   
   def test_should_raise_exception_when_block_yields_false
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      should do
-        false
-      end
+      5.should.satisfy { false }
     end
   end
   
   def test_should_not_raise_exception_when_block_yields_true
     assert_nothing_raised do
-      should do
-        true
-      end
+      5.should.satisfy { true }
     end
   end
 
-  # should_equal
+  # should.not.satisfy
+  
+  def test_should_raise_exception_when_block_yields_false
+    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      5.should.not.satisfy { true }
+    end
+  end
+  
+  def test_should_not_raise_exception_when_block_yields_true
+    assert_nothing_raised do
+      5.should.not.satisfy { false }
+    end
+  end
+
+  # should.equal
   
   def test_should_equal_should_not_raise_when_objects_are_equal
     assert_nothing_raised do
-      @dummy.should_equal(@equal_dummy)
+      @dummy.should.equal @equal_dummy
     end
   end
   
   def test_should_equal_should_raise_when_objects_are_not_equal
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_equal(@another_dummy)
+      @dummy.should.equal @another_dummy
     end
   end
 
-  # should_not_equal
+  # should.not.equal
 
   def test_should_not_equal_should_not_raise_when_objects_are_not_equal
     assert_nothing_raised do
-      @dummy.should_not_equal(@another_dummy)
+      @dummy.should.not.equal @another_dummy
     end
   end
 
   def test_should_not_equal_should_raise_when_objects_are_not_equal
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_not_equal(@equal_dummy)
+      @dummy.should.not.equal @equal_dummy
     end
   end
 
-  # should_be_same_as
+  # should.be
 
   def test_should_be_same_as_should_not_raise_when_objects_are_same
     assert_nothing_raised do
-      @dummy.should_be_same_as(@dummy)
+      @dummy.should.be @dummy
     end
   end
 
   def test_should_be_same_as_should_raise_when_objects_are_not_same
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_be_same_as(@equal_dummy)
+      @dummy.should.be @equal_dummy
     end
   end
 
-  # should_not_be_same_as
-
-  def test_should_not_be_same_as_should_not_raise_when_objects_are_not_same
+  def test_should_be_nil_should_not_raise_when_object_is_nil
     assert_nothing_raised do
-      @dummy.should_not_be_same_as(@equal_dummy)
-    end
+      @nil_var.should.be nil
+    end  
   end
 
-  def test_should_not_be_same_as_should_raise_when_objects_are_not_same
+  def test_should_be_nil_should_raise_when_object_is_not_nil
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_not_be_same_as(@dummy)
+      @dummy.should.be nil
     end
   end
 
-  # should_match
+  # should.not.be
 
-  def test_should_match_should_not_raise_when_objects_match
+  def test_should_not_be_same_as_should_not_raise_when_objects_are_not_same
     assert_nothing_raised do
-      "hi aslak".should_match /aslak/
+      @dummy.should.not.be @equal_dummy
     end
   end
 
-  def test_should_equal_should_raise_when_objects_do_not_match
+  def test_should_not_be_same_as_should_raise_when_objects_are_not_same
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      "hi aslak".should_match /steve/
+      @dummy.should.not.be @dummy
     end
   end
 
-  # should_not_match
-
-  def test_should_not_match_should_not_raise_when_objects_do_not_match
+  def test_should_not_be_nil_should_not_raise_when_object_is_not_nil
     assert_nothing_raised do
-      "hi aslak".should_not_match /steve/
-    end
+      @dummy.should.not.be nil
+    end  
   end
 
-  def test_should_not_match_should_raise_when_objects_match
+  def test_should_not_be_nil_should_raise_when_object_is_nil
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      "hi aslak".should_not_match /aslak/
+      @nil_var.should.not.be nil
     end
   end
 
-  # should_be_nil
+# should.match
 
-  def test_should_be_nil_should_not_raise_when_object_is_nil
+  def test_should_match_should_not_raise_when_objects_match
     assert_nothing_raised do
-      @nil_var.should_be_nil
-    end  
+      "hi aslak".should.match /aslak/
+    end
   end
 
-  def test_should_be_nil_should_raise_when_object_is_not_nil
+  def test_should_equal_should_raise_when_objects_do_not_match
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_be_nil
+      "hi aslak".should.match /steve/
     end
   end
-  
-  # should_not_be_nil
 
-  def test_should_not_be_nil_should_not_raise_when_object_is_not_nil
+  # should.not.match
+
+  def test_should_not_match_should_not_raise_when_objects_do_not_match
     assert_nothing_raised do
-      @dummy.should_not_be_nil
-    end  
+      "hi aslak".should.not.match /steve/
+    end
   end
 
-  def test_should_not_be_nil_should_raise_when_object_is_nil
+  def test_should_not_match_should_raise_when_objects_match
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @nil_var.should_not_be_nil
+      "hi aslak".should.not.match /aslak/
     end
   end
       
-  # should_be_empty
+  # should.be.xxx
 
-  def test_should_be_empty_should_raise_when_object_is_not_a_container
-    assert_raise(NoMethodError) do
-      5.should_be_empty
+	def test_should_be_xxx_should_raise_when_target_doesnt_understand_xxx
+		assert_raise(NoMethodError) do
+      5.should.be.xxx
     end
-  end
+	end
 
-  def test_should_be_empty_should_raise_when_object_is_a_non_empty_array
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      [1, 2, 3].should_be_empty
+	def test_should_be_xxx_should_raise_when_sending_xxx_to_target_returns_false
+		mock = Mock.new("xxx? returns false")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(false)
+	  assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      mock.should.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_array
-    assert_nothing_raised do
-      [].should_be_empty
+	def test_should_be_xxx_should_raise_when_sending_xxx_to_target_returns_nil
+		mock = Mock.new("xxx? returns nil")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(nil)
+	  assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      mock.should.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_be_empty_should_raise_when_object_is_a_non_empty_hash
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      {"a" => 1}.should_be_empty
+	def test_should_be_xxx_should_not_raise_when_sending_xxx_to_target_returns_true
+		mock = Mock.new("xxx? returns true")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(true)
+	  assert_nothing_raised do
+      mock.should.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_hash
-    assert_nothing_raised do
-      {}.should_be_empty
+	def test_should_be_xxx_should_not_raise_when_sending_xxx_to_target_returns_something_other_than_true_false_or_nil
+		mock = Mock.new("xxx? returns 5")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(5)
+	  assert_nothing_raised do
+      mock.should.be.xxx
     end
+		mock.__verify
   end
-  
-  # should_not_be_empty
 
-  def test_should_be_empty_should_raise_when_object_is_a_non_empty_string
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_be_empty
+	# should.be.xxx(args)
+	
+  def test_should_be_xxx_with_args_passes_args_properly
+ 		mock = Mock.new("xxx?(1 2 3) returns true")
+		mock.should_receive(:xxx?).once.with(1, 2, 3).and_return(true)
+	  assert_nothing_raised do
+      mock.should.be.xxx(1, 2, 3)
     end
+		mock.__verify
   end
 
-  def test_should_be_empty_shouldnt_raise_when_object_is_an_empty_string
-    assert_nothing_raised do
-      "".should_be_empty
-    end
-  end
+  # should.not.be.xxx
 
-  def test_should_not_be_empty_should_raise_when_object_is_not_a_container
-    assert_raise(NoMethodError) do
-      5.should_not_be_empty
+	def test_should_not_be_xxx_should_raise_when_target_doesnt_understand_xxx
+		assert_raise(NoMethodError) do
+      5.should.not.be.xxx
     end
-  end
+	end
 
-  def test_should_not_be_empty_should_raise_when_object_is_an_empty_array
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      [].should_not_be_empty
+	def test_should_not_be_xxx_should_raise_when_sending_xxx_to_target_returns_true
+		mock = Mock.new("xxx? returns true")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(true)
+	  assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      mock.should.not.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_array
-    assert_nothing_raised do
-      [1, 2, 3].should_not_be_empty
+	def test_should_not_be_xxx_shouldnt_raise_when_sending_xxx_to_target_returns_nil
+		mock = Mock.new("xxx? returns nil")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(nil)
+	  assert_nothing_raised do
+      mock.should.not.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_not_be_empty_should_raise_when_object_is_an_empty_hash
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      {}.should_not_be_empty
+	def test_should_not_be_xxx_shouldnt_raise_when_sending_xxx_to_target_returns_false
+		mock = Mock.new("xxx? returns false")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(false)
+	  assert_nothing_raised do
+      mock.should.not.be.xxx
     end
+		mock.__verify
   end
 
-  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_hash
-    assert_nothing_raised do
-      {"a"=>1}.should_not_be_empty
+	def test_should_not_be_xxx_should_raise_when_sending_xxx_to_target_returns_something_other_than_true_false_or_nil
+		mock = Mock.new("xxx? returns 5")
+		mock.should_receive(:xxx?).once.with_no_args.and_return(5)
+	  assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+      mock.should.not.be.xxx
     end
+		mock.__verify
   end
-
-  def test_should_not_be_empty_should_raise_when_object_is_an_empty_string
-    assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      "".should_not_be_empty
+  
+  
+	# should.be.xxx(args)
+	
+  def test_should_not_be_xxx_with_args_passes_args_properly
+ 		mock = Mock.new("xxx?(1 2 3) returns false")
+		mock.should_receive(:xxx?).once.with(1, 2, 3).and_return(false)
+	  assert_nothing_raised do
+      mock.should.not.be.xxx(1, 2, 3)
     end
+		mock.__verify
   end
 
-  def test_should_not_be_empty_shouldnt_raise_when_object_is_a_non_empty_string
-    assert_nothing_raised do
-      @dummy.should_not_be_empty
-    end
-  end
-  
   # should_include
   
   def test_should_include_shouldnt_raise_when_string_inclusion_is_present
     assert_nothing_raised do
-      @dummy.should_include("mm")
+      @dummy.should.include "mm"
     end
   end
   
   def test_should_include_should_raise_when_string_inclusion_is_missing
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_include("abc")
+      @dummy.should.include "abc" 
     end
   end
 
   def test_should_include_shouldnt_raise_when_array_inclusion_is_present
     assert_nothing_raised do
-      [1, 2, 3].should_include(2)
+      [1, 2, 3].should.include 2
     end
   end
 
   def test_should_include_should_raise_when_array_inclusion_is_missing
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      [1, 2, 3].should_include(5)
+      [1, 2, 3].should.include 5
     end
   end
 
   def test_should_include_shouldnt_raise_when_hash_inclusion_is_present
     assert_nothing_raised do
-      {"a"=>1}.should_include("a")
+      {"a"=>1}.should.include "a"
     end
   end
 
   def test_should_include_should_raise_when_hash_inclusion_is_missing
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      {"a"=>1}.should_include("b")
+      {"a"=>1}.should.include "b"
     end
   end
 
   def test_should_include_shouldnt_raise_when_enumerable_inclusion_is_present
     assert_nothing_raised do
-      IO.constants.should_include("SEEK_SET")
+      IO.constants.should.include "SEEK_SET"
     end
   end
 
   def test_should_include_should_raise_when_enumerable_inclusion_is_missing
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      IO.constants.should_include("BLAH")
+      IO.constants.should.include "BLAH"
     end
   end
   
@@ -293,49 +322,49 @@ class ExpectationsTest < Test::Unit::TestCase
   
   def test_should_not_include_shouldnt_raise_when_string_inclusion_is_missing
     assert_nothing_raised do
-      @dummy.should_not_include("abc")
+      @dummy.should.not.include "abc"
     end
   end
 
   def test_should_not_include_should_raise_when_string_inclusion_is_present
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      @dummy.should_not_include("mm")
+      @dummy.should.not.include "mm"
     end
   end
 
   def test_should_not_include_shouldnt_raise_when_array_inclusion_is_missing
     assert_nothing_raised do
-      [1, 2, 3].should_not_include(5)
+      [1, 2, 3].should.not.include 5
     end
   end
 
   def test_should_not_include_should_raise_when_array_inclusion_is_present
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      [1, 2, 3].should_not_include(2)
+      [1, 2, 3].should.not.include 2
     end
   end
 
   def test_should_not_include_shouldnt_raise_when_hash_inclusion_is_missing
     assert_nothing_raised do
-      {"a"=>1}.should_not_include("b")
+      {"a"=>1}.should.not.include "b"
     end
   end
 
   def test_should_not_include_should_raise_when_hash_inclusion_is_present
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      {"a"=>1}.should_not_include("a")
+      {"a"=>1}.should.not.include "a"
     end
   end
 
   def test_should_not_include_shouldnt_raise_when_enumerable_inclusion_is_present
     assert_nothing_raised do
-      IO.constants.should_not_include("BLAH")
+      IO.constants.should.not.include "BLAH"
     end
   end
 
   def test_should_not_include_should_raise_when_enumerable_inclusion_is_missing
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      IO.constants.should_not_include("SEEK_SET")
+      IO.constants.should.not.include "SEEK_SET" 
     end
   end
   
@@ -348,120 +377,216 @@ class ExpectationsTest < Test::Unit::TestCase
     end
   end
   
-  # should_be_true
+  # should.be true
   
   def test_should_be_true_should_raise_when_object_is_nil
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      nil.should_be_true
+      nil.should.be true
     end
   end
   
   def test_should_be_true_should_raise_when_object_is_false
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      false.should_be_true
+      false.should.be true
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_true
     assert_nothing_raised do
-      true.should_be_true
+      true.should.be true
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_a_number
     assert_nothing_raised do
-      5.should_be_true
+      5.should.be true
     end
   end
   
   def test_should_be_true_shouldnt_raise_when_object_is_a_string
     assert_nothing_raised do
-      "hello".should_be_true
+      "hello".should.be true
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_a_some_random_object
     assert_nothing_raised do
-      self.should_be_true
+      self.should.be true
     end
   end
 
-  # should_be_false
+  # should.be false
 
-  def test_should_be_true_shouldnt_raise_when_object_is_nil
+  def test_should_be_false_shouldnt_raise_when_object_is_nil
     assert_nothing_raised do
-      nil.should_be_false
+      nil.should.be false
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_false
     assert_nothing_raised do
-      false.should_be_false
+      false.should.be false
     end
   end
 
   def test_should_be_true_should_raise_when_object_is_true
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      true.should_be_false
+      true.should.be false
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_a_number
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      5.should_be_false
+      5.should.be false
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_a_string
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      "hello".should_be_false
+      "hello".should.be false
     end
   end
 
   def test_should_be_true_shouldnt_raise_when_object_is_a_some_random_object
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      self.should_be_false
+      self.should.be false
     end
   end
-  
-  # should_raise
+
+  # should.raise
   
   def test_should_raise_should_pass_when_proper_exception_is_raised
     assert_nothing_raised do
-      proc { ''.nonexistant_method }.should_raise(NoMethodError)
+      proc { ''.nonexistant_method }.should.raise NoMethodError
     end
   end
   
-  def test_should_raise_should_not_pass_when_wrong_exception_is_raised
+  def test_should_raise_should_fail_when_wrong_exception_is_raised
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      proc { ''.nonexistant_method }.should_raise(SyntaxError)
+      proc { ''.nonexistant_method }.should.raise SyntaxError
     end
   end
   
-  def test_should_raise_should_not_pass_with_no_exception
+  def test_should_raise_should_fail_when_no_exception_is_raised
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      not proc {''.to_s}.should_raise(NoMethodError)
+      proc {''.to_s}.should.raise NoMethodError
     end
   end
   
-  # should_not_raise
+  # should.not.raise
   
-  def test_should_not_raise_should_pass_when_proper_exception_is_raised
+  def test_should_not_raise_should_fail_when_specific_exception_is_raised
     assert_raise(Spec::Exceptions::ExpectationNotMetError) do
-      proc { ''.nonexistant_method }.should_not_raise(NoMethodError)
+      proc { ''.nonexistant_method }.should.not.raise NoMethodError
     end
   end
   
-  def test_should_not_raise_should_not_pass_when_wrong_exception_is_raised
+  def test_should_not_raise_should_pass_when_other_exception_is_raised
     assert_nothing_raised do
-      proc { ''.nonexistant_method }.should_not_raise(SyntaxError)
+      proc { ''.nonexistant_method }.should.not.raise SyntaxError
     end
   end
   
-  def test_should_not_raise_should_not_pass_with_no_exception
-    assert_nothing_raised do
-      not proc { ''.to_s }.should_not_raise(NoMethodError)
-    end
-  end
+  def test_should_not_raise_should_pass_when_no_exception_is_raised
+    assert_nothing_raised do
+      proc { ''.to_s }.should.not.raise NoMethodError
+    end
+  end
+
+	# should.be.an.instance.of <class>
+	
+	def test_should_be_an_instance_of_should_pass_when_target_is_specified_class
+		assert_nothing_raised do
+			5.should.be.an.instance.of Fixnum
+		end
+	end
+	
+	def test_should_be_an_instance_of_should_fail_when_target_is_not_specified_class
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			5.should.be.an.instance.of Integer
+		end
+	end
+	
+	# should.be.a.kind.of <class>
+	
+	def test_should_be_a_kind_of_should_pass_when_target_is_of_specified_class
+		assert_nothing_raised do
+			5.should.be.a.kind.of Fixnum
+		end
+	end
+
+	def test_should_be_a_kind_of_should_pass_when_target_is_of_subclass_of_specified_class
+		assert_nothing_raised do
+			5.should.be.a.kind.of Integer
+		end
+	end
+
+	def test_should_be_an_instance_of_should_fail_when_target_is_not_specified_class
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			5.should.be.a.kind.of String
+		end
+	end
+	
+	# should.not.be.an.instance_of <class>
+	
+	def test_should_not_be_an_instance_of_should_fail_when_target_is_of_specified_class
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			'hello'.should.not.be.an.instance.of String
+		end
+	end
+	
+	def test_should_be_an_instance_of_should_pass_when_target_is_not_of_specified_class
+		assert_nothing_raised do
+			[].should.not.be.an.instance.of String
+		end
+	end
+
+	# should.be.a.kind.of <class>
+	
+	def test_should_not_be_a_kind_of_should_fail_when_target_is_of_specified_class
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			5.should.not.be.a.kind.of Fixnum
+		end
+	end
+
+	def test_should_not_be_a_kind_of_should_fail_when_target_is_of_subclass_of_specified_class
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			5.should.not.be.a.kind.of Integer
+		end
+	end
+
+	def test_should_not_be_an_instance_of_should_pass_when_target_is_not_specified_class
+		assert_nothing_raised do
+			5.should.not.be.a.kind.of String
+		end
+	end
+	
+	# should.respond.to <message>
+	
+	def test_should_respond_to_should_pass_when_target_does
+		assert_nothing_raised do
+			"".should.respond.to :length
+		end
+	end
+
+	def test_should_respond_to_should_fail_when_target_doesnt
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			"".should.respond.to :connect
+		end
+	end
+
+	# should.not.respond.to <message>
+	
+	def test_not_should_respond_to_should_fail_when_target_does
+		assert_raise(Spec::Exceptions::ExpectationNotMetError) do
+			"".should.not.respond.to :length
+		end
+	end
+
+	def test_not_should_respond_to_should_pass_when_target_doesnt
+		assert_nothing_raised do
+			"".should.not.respond.to :connect
+		end
+	end
 
 end