wrong 0.4.3-java → 0.4.4-java

data/README.markdown

@@ -57,13 +57,16 @@ If your assertion is more than a simple predicate, then Wrong will split it into
 And a companion, 'deny':
 
 	deny{'abc'.include?('bc')}
-	 ==> Didn't expect "abc".include?("bc"), but 'abc' includes 'bc'
+	 ==> Didn't expect "abc".include?("bc")
 
 There's also a convenience method for catching errors:
 
     assert{ rescuing{raise "vanilla"}.message == "chocolate" }
 	 ==>
-    Expected (rescuing { raise("vanilla") }.message == "chocolate"), but 'vanilla' is not equal to 'chocolate'
+    Expected (rescuing { raise("vanilla") }.message == "chocolate"), but
+        rescuing { raise("vanilla") }.message is "vanilla"
+        rescuing { raise("vanilla") } is #<RuntimeError: vanilla>
+        raise("vanilla") raises RuntimeError: vanilla
 
 And one for capturing output streams:
 
@@ -89,7 +92,7 @@ We also implement the most amazing debugging method ever, `d`, which gives you a
     d { x } # => prints "x is 7" to the console
     d { x * 2 } # => prints "(x * 2) is 14" to the console
 
-(`d` was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this is a rewrite and homage.) Remember, if you want `d` to work at runtime (e.g. in a webapp) then you must `include 'wrong/d'` inside your app, e.g. for in your `environment.rb` file.
+(`d` was originally implemented by Rob Sanheim in LogBuddy; as with Assert2 this version is a rewrite and homage.) Remember, if you want `d` to work at runtime (e.g. in a webapp) then you must `include Wrong::D` inside your app, e.g. in your `environment.rb` file.
 
 More examples are in the file `examples.rb` <http://github.com/alexch/wrong/blob/master/examples.rb>
 
@@ -114,7 +117,7 @@ will give you the `assert` and `deny` methods but not the formatters or `rescuin
     require 'wrong/d'
     include Wrong::D
 
-To summarize: if you do `require 'wrong'` and `include Wrong` then you will get the whole ball of wax. Most people will probably want this since it's easier, but there is an alternative, whici is to `require` and `include` only what you want.
+To summarize: if you do `require 'wrong'` and `include Wrong` then you will get the whole ball of wax. Most people will probably want this since it's easier, but there is an alternative, which is to `require` and `include` only what you want.
 
 And beware: if you don't `require 'wrong'`, then `include Wrong` will not do anything at all.
 
@@ -144,6 +147,32 @@ Wrong also lets you put the expected and actual values in any order you want! Co
 
 You get all the information you want, and none you don't want. At least, that's the plan! :-)
 
+## BDD with Wrong ##
+
+Wrong is compatible with RSpec and MiniTest::Spec, and probably Cucumber too, so you can use it inside your BDD framework of choice. To make your test code even BDD-er, try aliasing `assert` to either `should` or (Alex's favorite) `expect`. 
+
+Here's an RSpec example: 
+
+    require "wrong"
+	require "wrong/adapters/rspec"
+	Wrong.config.alias_assert :expect
+	
+	describe BleuCheese do
+	  it "stinks" do
+		expect { BleuCheese.new.smell > 9000 }
+  	  end
+	end
+
+This makes your code read like a BDD-style DSL, without RSpec's arcane "should" syntax (which is, let's face it, pretty weird the first few hundred times you have to use it). Compare
+
+    expect { BleuCheese.new.smell > 9000 }
+
+ to
+ 
+    BleuCheese.new.smell.should > 9000
+
+and seriously, tell me which one more clearly describes the desired behavior. The object under test doesn't really have a `should` method, so why should it during a test? And in what human language is "should greater than" a valid phrase?
+
 ## Algorithm ##
 
 So wait a second. How do we do it? Doesn't Ruby have [poor support for AST introspection](http://blog.zenspider.com/2009/04/parsetree-eol.html)? Well, yes, it does, so we cheat: we figure out what file and line the assert block is defined in, then open the file, read the code, and parse it directly using Ryan Davis' amazing [RubyParser](http://parsetree.rubyforge.org/ruby_parser/) and [Ruby2Ruby](http://seattlerb.rubyforge.org/ruby2ruby/). You can bask in the kludge by examining `chunk.rb` and `assert.rb`. If you find some code it can't parse, please send it our way.
@@ -193,13 +222,12 @@ And if your assertion code isn't self-explanatory, then that's a hint that you m
 
 When a failure occurs, the exception message contains all the details you might need to make sense of it. Here's the breakdown:
 
-    Expected [CLAIM], but [SUMMARY]
+    Expected [CLAIM], but
       [FORMATTER]
       [SUBEXP] is [VALUE]
       ...
 
 * CLAIM is the code inside your assert block, normalized
-* SUMMARY is a to-English translation of the claim, via the Predicated library. This tries to be very intelligible; e.g. translating "include?" into "does not include" and so on.
 * If there is a formatter registered for this type of predicate, its output will come next. (See below.)
 * SUBEXP is each of the subtrees of the claim, minus duplicates and truisms (e.g. literals).
 * The word "is" is a very nice separator since it doesn't look like code, but is short enough to be easily visually parsed.
@@ -209,6 +237,8 @@ We hope this structure lets your eyes focus on the meaningful values and differe
 
 (Why does VALUE use `inspect` and not `to_s`? Because `inspect` on standard objects like String and Array are sure to show all relevant details, such as white space, in a console-safe way, and we hope other libraries follow suit. Also, `to_s` often inserts line breaks and that messes up formatting and legibility.)
 
+Wrong tries to maintain indentation to improve readability. If the inspected VALUE contains newlines, the succeeding lines will be indented to the correct level.
+
 ## Formatters ##
 
 Enhancements for error messages sit under wrong/message.
@@ -216,22 +246,19 @@ Enhancements for error messages sit under wrong/message.
 Currently we support special messages for
 
   * String ==
-  * Enumerable ==
+  * Array(ish) ==
     * including nested string elements
 
-To use these formatters, you have to explicitly `require` them! You may also need to `gem install diff-lcs` (since it's an optional dependency).
+To use the Array formatter, you may also need to `gem install diff-lcs` (it's an optional dependency).
 
-    require "wrong/message/string_diff"
+    require "wrong/message/string_comparison"
     assert { "the quick brown fox jumped over the lazy dog" ==
              "the quick brown hamster jumped over the lazy gerbil" }
      ==>
-    Expected ("the quick brown fox jumped over the lazy dog" == "the quick brown hamster jumped over the lazy gerbil"), but "the quick brown fox jumped over the lazy dog" is not equal to "the quick brown hamster jumped over the lazy gerbil"
-
-    string diff:
-    the quick brown fox jumped over the lazy dog
-                    ^^^
-    the quick brown hamster jumped over the lazy gerbil
-                    ^^^^^^^
+	Expected ("the quick brown fox jumped over the lazy dog" == "the quick brown hamster jumped over the lazy gerbil"), but
+	Strings differ at position 16:
+	 first: ..."quick brown fox jumped over the lazy dog"
+	second: ..."quick brown hamster jumped over the lazy gerbil"
 --
 
     require "wrong/message/array_diff"
@@ -245,8 +272,6 @@ To use these formatters, you have to explicitly `require` them! You may also nee
     ["venus", "earth", "pluto", "neptune"]
               ^                 ^
 
-[Bug: turns out 'diff' and 'diff-lcs' are incompatible with each other. We're working on a fix.]
-
 ## Config ##
 
 These settings can either be set at runtime on the `Wrong.config` singleton, or inside a `.wrong` file in the current directory or a parent. In the `.wrong` file just pretend every line is preceded with `Wrong.config.` -- e.g. if there's a setting called `ice_cream`, you can do any of these in your `.wrong` file
@@ -275,7 +300,12 @@ in your `.wrong` file and get ready to be **bedazzled**. If you need custom colo
 
 ### Aliases ###
 
-An end to the language wars! Name your "assert" and "deny" methods anything you want. In your code, use `Wrong.config.alias_assert` and `Wrong.config.alias_deny`, and in your `.wrong` file, use Here are some suggestions:
+An end to the language wars! Name your "assert" and "deny" methods anything you want. 
+
+* In your code, use `Wrong.config.alias_assert` and `Wrong.config.alias_deny`
+* In your `.wrong` file, put `alias_assert :expect` on a line by itself
+
+Here are some suggestions:
 
     alias_assert :expect
     alias_assert :should # This looks nice in RSpec

data/lib/wrong.rb

@@ -20,8 +20,19 @@ module Wrong
   extend Wrong::Helpers
 end
 
-# this does some magic; if you don't like it, `require 'wrong/assert'` et al. individually and don't `require 'wrong/close_to'` or `require 'wrong'`
+# this does some magic; if you don't like it...
+
+# ...`require 'wrong/assert'` et al. individually and don't `require 'wrong/close_to'` or `require 'wrong'`
 require "wrong/close_to"
 
-# this does some magic; if you don't like it, `require 'wrong/assert'` et al. individually, don't `require 'wrong'`, and `include Wrong::D` only in the modules you want to call `d` from
-Object.send :include, Wrong::D
+# ...don't `require 'wrong'`, and `include Wrong::D` only in the modules you want to call `d` from
+class Object
+  include Wrong::D
+end
+
+# ...don't `require 'wrong'`
+# this part isn't working yet -- it's supposed to make 'assert' available at the top level but it breaks the minitest adapter
+# include Wrong
+# class Object
+#   include Wrong
+# end

data/lib/wrong/adapters/minitest.rb

@@ -1,7 +1,9 @@
-require "wrong"
+require "wrong/assert"
+require "wrong/helpers"
 
 class MiniTest::Unit::TestCase
-  include Wrong
+  include Wrong::Assert
+  include Wrong::Helpers
 
   def failure_class
     MiniTest::Assertion
@@ -11,4 +13,5 @@ class MiniTest::Unit::TestCase
     self._assertions += 1 # increment minitest's assert count
     super(valence, explanation, depth + 1) # apparently this passes along the default block
   end
+  
 end

data/lib/wrong/assert.rb

@@ -48,10 +48,6 @@ module Wrong
       end
     end
 
-    def summary(method_sym, predicate)
-      method_sym == :deny ? predicate.to_sentence : predicate.to_negative_sentence
-    end
-
     protected
 
     # for debugging -- if we couldn't make a predicate out of the code block, then this was why
@@ -59,34 +55,6 @@ module Wrong
       @@last_predicated_error ||= nil
     end
 
-    # todo: move some/all of this into FailureMessage
-    def full_message(chunk, block, valence, explanation)
-      code = chunk.code
-
-      predicate = begin
-        Predicated::Predicate.from_ruby_code_string(code, block.binding)
-      rescue Predicated::Predicate::DontKnowWhatToDoWithThisSexpError, Exception => e
-        # save it off for debugging
-        @@last_predicated_error = e
-        nil
-      end
-
-      code = code.color(:blue) if Wrong.config[:color]
-      message = ""
-      message << "#{explanation}: " if explanation
-      message << "#{valence == :deny ? "Didn't expect" : "Expected"} #{code}, but "
-      if predicate && !(predicate.is_a? Predicated::Conjunction)
-        message << summary(valence, predicate)
-        if formatter = FailureMessage.formatter_for(predicate)
-          failure = formatter.describe
-          failure = failure.bold if Wrong.config[:color]
-          message << failure
-        end
-      end
-      message << chunk.details
-      message
-    end
-
     def aver(valence, explanation = nil, depth = 0, &block)
       require "wrong/rainbow" if Wrong.config[:color]
 
@@ -96,7 +64,7 @@ module Wrong
 
         chunk = Wrong::Chunk.from_block(block, depth + 2)
 
-        message = full_message(chunk, block, valence, explanation)
+        message = FailureMessage.new(chunk, block, valence, explanation).full
         raise failure_class.new(message)
       end
     end

data/lib/wrong/chunk.rb

@@ -143,7 +143,7 @@ module Wrong
         # todo: extract some of this into Sexp
         parts_list = []
         begin
-          unless sexp.first == :arglist
+          unless sexp.first == :arglist # or sexp.first == :iter
             code = sexp.to_ruby.strip
             parts_list << code unless code == "" || parts_list.include?(code)
           end
@@ -167,6 +167,12 @@ module Wrong
     end
 
     def details
+      @details ||= build_details
+    end
+
+    private
+
+    def build_details
       require "wrong/rainbow" if Wrong.config[:color]
       s = ""
       parts = self.parts
@@ -215,8 +221,6 @@ module Wrong
 
     end
 
-    private
-
     def indent(indent, *s)
       "#{"  " * indent}#{s.join('')}"
     end

data/lib/wrong/failure_message.rb

@@ -39,5 +39,59 @@ module Wrong
         false
       end
     end
+    
+    
+    attr_accessor :chunk, :block, :valence, :explanation
+
+    def initialize(chunk, block, valence, explanation)
+      @chunk, @block, @valence, @explanation = chunk, block, valence, explanation
+    end
+
+    def basic
+      "#{valence == :deny ? "Didn't expect" : "Expected"} #{chunk.code}"
+    end
+    
+    def full
+      message = ""
+      message << "#{explanation}: " if explanation
+      message << basic
+      
+      formatted_message = if predicate && !(predicate.is_a? Predicated::Conjunction)
+        if formatter = FailureMessage.formatter_for(predicate)
+          failure = formatter.describe
+          failure = failure.bold if Wrong.config[:color]
+          failure
+        end
+      end
+      
+      unless chunk.details.empty? and formatted_message.nil?
+        message << ", but"
+      end
+      
+      message << formatted_message if formatted_message
+      message << chunk.details unless chunk.details.empty?
+      message
+    end
+
+    protected    
+    def code
+      @code ||= begin
+        code = chunk.code
+        code = code.color(:blue) if Wrong.config[:color]
+        code
+      end
+    end
+    
+    def predicate
+      @predicate ||= begin
+        Predicated::Predicate.from_ruby_code_string(code, block.binding)
+      rescue Predicated::Predicate::DontKnowWhatToDoWithThisSexpError, Exception => e
+        # save it off for debugging
+        @@last_predicated_error = e
+        nil
+      end
+    end
+    
+
   end
 end

data/lib/wrong/message/array_diff.rb

@@ -13,7 +13,7 @@ module Wrong
 
     def arrayish?(object)
       # in some Rubies, String is Enumerable
-      object.is_a?(Enumerable) && !object.is_a?(String)
+      object.is_a?(Enumerable) && !(object.is_a?(String) || object.is_a?(Hash))
     end
 
     def describe

data/lib/wrong/sexp_ext.rb

@@ -5,8 +5,8 @@ require 'wrong/config'
 class Sexp < Array
 
   def to_ruby
-    d = self.deep_clone
-    ruby = Ruby2Ruby.new.process(d)
+    sexp = self.deep_clone
+    ruby = Ruby2Ruby.new.process(sexp)
     ruby
   end
 
@@ -26,7 +26,7 @@ class Sexp < Array
       self[0] == :iter and
       self[1].is_a? Sexp and
       self[1][0] == :call and
-      Wrong.config.assert_methods.include? self[1][2] # todo: allow aliases for assert (e.g. "is")
+      Wrong.config.assert_methods.include? self[1][2]
   end
 
   def assertion

data/lib/wrong/version.rb

@@ -1,3 +1,3 @@
 module Wrong
-  VERSION = "0.4.3" unless defined?(Wrong::VERSION)
+  VERSION = "0.4.4" unless defined?(Wrong::VERSION)
 end

data/test/adapters/minitest_test.rb

@@ -61,11 +61,10 @@ describe "basic assert features" do
     end
 
     msg = rescuing { MyFailingAssertTest.new.test_fail }.message
-
-    assert { msg.include?("1 is not equal to 2") }
+    assert { msg.include?("Expected (1 == 2)") }
 
     msg = rescuing { MyFailingDenyTest.new.test_fail }.message
-    assert { msg.include?("1 is equal to 1") }
+    assert { msg.include?("Didn't expect (1 == 1)") }
   end
 end
 

data/test/adapters/railsapp/config/initializers/secret_token.rb

@@ -4,4 +4,4 @@
 # If you change this key, all old signed cookies will become invalid!
 # Make sure the secret is at least 30 characters and all random,
 # no regular words or you'll be exposed to dictionary attacks.
-Railsapp::Application.config.secret_token = 'c70ec52a76ff610e2e1630245d880922ed317debad0d2cfdab8744de26c3ddcc9379f651877b0cf51905efd285c1d0bdabd3a5c36572d245d81a98c763c2822b'
+Railsapp::Application.config.secret_token = '60ef44ef55c7289c9013546cef8ef9aa67efd47177d7b4dbd85535f25de545a448e97eb62b9ce64df8aad9ec765d6c08d3725b738b9cbb503b978a61d765224b'

data/test/adapters/test_unit_test.rb

@@ -32,13 +32,13 @@ class MyFailingAssertTest <  Test::Unit::TestCase
     #I can do without all the TU Listener business, thank you
     failures = result.instance_variable_get("@failures".to_sym)
     assert{ failures.length==1 }
-    assert{ failures.first.long_display.include?("1 is not equal to 2") }
+    assert{ failures.first.long_display.include?("Expected (1 == 2)") }
     
     result = Test::Unit::TestResult.new
     failures = result.instance_variable_get("@failures".to_sym)
     my_failing_deny_test.new("test_fail").run(result) {|started, name| }
     assert{ failures.length==1 }
-    assert{ failures.first.long_display.include?("1 is equal to 1") }
+    assert{ failures.first.long_display.include?("Didn't expect (1 == 1)") }
   end
 
   def test_passes_asserts_with_no_block_up_to_the_frameworks_assert_method

data/test/config_test.rb

@@ -91,7 +91,7 @@ alias_assert :yum
           is("math is hard") { 2 + 2 == 5 }
         }
         expected = <<-FAIL
-math is hard: Expected ((2 + 2) == 5), but 4 is not equal to 5
+math is hard: Expected ((2 + 2) == 5), but
     (2 + 2) is 4
         FAIL
         assert { e.message == expected }
@@ -118,7 +118,7 @@ math is hard: Expected ((2 + 2) == 5), but 4 is not equal to 5
           aint("math is hard") { 2 + 2 == 4 }
         }
         expected = <<-FAIL
-math is hard: Didn't expect ((2 + 2) == 4), but 4 is equal to 4
+math is hard: Didn't expect ((2 + 2) == 4), but
     (2 + 2) is 4
         FAIL
         assert { e.message == expected }

data/test/failure_message_test.rb

@@ -36,5 +36,50 @@ module Wrong
       assert { FailureMessage.formatters.include?(BogusFormatter)}
     end
 
+    def message(options = {})
+      block = options[:block] || proc { 2 + 2 == 5 }
+      chunk = Chunk.from_block(block)
+      valence = options[:valence] || :assert 
+      explanation = options[:explanation]
+      FailureMessage.new(chunk, block, valence, explanation)
+    end
+
+    describe "#basic" do      
+      it "shows the code" do
+        assert { message.basic == "Expected ((2 + 2) == 5)" }
+      end
+      
+      it "reverses the message for :deny valence" do
+        assert { message(:valence => :deny).basic == "Didn't expect ((2 + 2) == 5)" }
+      end
+    end
+    
+    describe '#full' do
+      it "contains the basic message" do
+        assert { message.full.include? message.basic }
+      end
+
+      it "contains the explanation if there is one" do
+        msg = message(:explanation => "the sky is falling")
+        assert { msg.full.include? "the sky is falling" }
+      end
+      
+      it "doesn't say 'but' if there are no details" do
+        block = proc { 7 }
+        chunk = Chunk.from_block(block)
+        assert { chunk.details.empty? }
+        msg = message(:block => block)
+        deny { msg.full.include? ", but"}
+      end
+      
+      it "say 'but' with if there are details" do
+        block = proc { 2 + 2 == 5 }
+        chunk = Chunk.from_block(block)
+        msg = message(:block => block)
+        assert { msg.full.include? ", but\n    (2 + 2) is 4"}
+      end
+      
+    end
+
   end
 end

data/test/failures_test.rb

@@ -1,6 +1,7 @@
 require "./test/test_helper"
 
 require "wrong/assert"
+require "wrong/sexp_ext"
 
 describe "failures" do
 
@@ -25,51 +26,17 @@ describe "failures" do
     end
 
     it "equality failure" do
-      assert_match "1 is not equal to 2", get_error {
+      assert_match "Expected (1 == 2)", get_error {
         @m.assert { 1==2 }
       }.message
-      assert_match "1 is equal to 1", get_error {
+      assert_match "Didn't expect (1 == 1)", get_error {
         @m.deny { 1==1 }
       }.message
     end
 
-    it "failure of basic operations" do
-      assert_match "1 is not greater than 2", get_error {
-        @m.assert { 1>2 }
-      }.message
-      assert_match "2 is not less than 1", get_error {
-        @m.assert { 2<1 }
-      }.message
-      assert_match "1 is not greater than or equal to 2", get_error {
-        @m.assert { 1>=2 }
-      }.message
-      assert_match "2 is not less than or equal to 1", get_error {
-        @m.assert { 2<=1 }
-      }.message
-
-      assert_match "2 is greater than 1", get_error {
-        @m.deny { 2>1 }
-      }.message
-      assert_match "1 is less than 2", get_error {
-        @m.deny { 1<2 }
-      }.message
-      assert_match "2 is greater than or equal to 1", get_error {
-        @m.deny { 2>=1 }
-      }.message
-      assert_match "1 is less than or equal to 2", get_error {
-        @m.deny { 1<=2 }
-      }.message
-    end
-
-    it "object failure" do
-      assert_match "Color:red is not equal to 2", get_error {
-        @m.assert { Color.new("red")==2 }
-      }.message
-    end
-
     it %{multiline assert block shouldn't look any different
            than when there everything is on one line} do
-      assert_match("1 is not equal to 2", get_error {
+      assert_match("Expected (1 == 2)", get_error {
         @m.assert {
           1==
                   2
@@ -82,52 +49,45 @@ describe "failures" do
   describe "accessing and printing values set outside of the assert" do
     it "use a value in the assert defined outside of it" do
       a = 1
-      assert_match "1 is not equal to 2", get_error {
+      assert_match "Expected (a == 2), but", get_error {
         @m.assert { a==2 }
       }.message
-      assert_match "1 is equal to 1", get_error {
+      assert_match "Didn't expect (a == 1)", get_error {
         @m.deny { a==1 }
       }.message
     end
   end
 
-  describe "conjunctions (and and or)" do
-    it "omit a primary failure message since 'This is not true etc.' is more obscuring than clarifying" do
-      m = get_error {
-        x = 5
-        @m.assert { x == 5 && x != 5 }
-      }.message
-      assert m == "Expected ((x == 5) and (not (x == 5))), but \n    (x == 5) is true\n    x is 5\n    (not (x == 5)) is false\n"
-    end
-  end
-
-  describe "the assert block has many statements" do
-    it "only pay attention to the final statement" do
-      assert_match("1 is not equal to 2", get_error {
-        @m.assert {
-          a = "aaa"
-          b = 1 + 2
-          c = ["foo", "bar"].length / 3
-          if a=="aaa"
-            b = 4
-          end; 1==2
-        }
-      }.message)
-    end
-
-    it "works even if the assertion is based on stuff set previously in the block" do
-      assert_match("\"aaa\" is not equal to \"bbb\"", get_error {
-        @m.assert {
-          a = "aaa"
-          a=="bbb"
-        }
-      }.message)
-    end
-  end
+  # describe "the assert block has many statements" do
+    # this is not true anymore -- should it be?
+    # it "only pay attention to the final statement" do
+    #   assert_match("Expected (1 == 2)", get_error {
+    #     @m.assert {
+    #       a = "aaa"
+    #       b = 1 + 2
+    #       c = ["foo", "bar"].length / 3
+    #       if a=="aaa"
+    #         b = 4
+    #       end; 1==2
+    #     }
+    #   }.message)
+    # end
+
+    # this raises an error trying to evaluate 'a'
+    it "works even if the assertion is based on stuff set previously in the block"
+     # do
+     #      assert_match(/Expected.*\(a == "bbb"\)/, get_error {
+     #        @m.assert {
+     #          a = "aaa"
+     #          a=="bbb"
+     #        }
+     #      }.message)
+     #    end
+  # end
 
   describe "array comparisons" do
     it "basic" do
-      assert_match %{[1, 2] is not equal to ["a", "b"]}, get_error {
+      assert_match 'Expected ([1, 2] == ["a", "b"])', get_error {
         @m.assert { [1, 2]==%w{a b} }
       }.message
     end
@@ -138,19 +98,14 @@ describe "failures" do
       e = get_error {
         @m.assert { {1=>2}=={"a"=>"b"} }
       }
-      assert_match '{1=>2} is not equal to {"a"=>"b"}',
-                   e.message
-    end
-  end
-
-  describe "methods that result in a boolean.  this might be hard." do
-    it "string include" do
-      assert_match "\"abc\" does not include \"cd\"", get_error {
-        @m.assert { "abc".include?("cd") }
-      }.message
-      assert_match "\"abc\" includes \"bc\"", get_error {
-        @m.deny { "abc".include?("bc") }
-      }.message
+      # this is weird; it should realize those details are truisms  -- must be a whitespace thing
+      expected =<<-TEXT
+Expected ({ 1 => 2 } == { "a" => "b" }), but
+    { 1 => 2 } is {1=>2}
+    { "a" => "b" } is {"a"=>"b"}
+      TEXT
+
+      assert_equal expected, e.message
     end
   end
 

data/test/message/array_diff_test.rb

@@ -27,6 +27,11 @@ describe "when you're comparing strings and they don't match, show me the diff m
         assert { nil==[1] }
       }.message.include?("^")
     }
+    deny {
+      rescuing {
+        assert { {:a=>1}==[1] }
+      }.message.include?("^")
+    }
   end
 
   it "simple" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 4
-  - 3
-  version: 0.4.3
+  - 4
+  version: 0.4.4
 platform: java
 authors: 
 - Steve Conover
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-20 00:00:00 -07:00
+date: 2010-11-12 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -182,7 +182,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 219727975865323768
+      hash: 997316472760642936
       segments: 
       - 0
       version: "0"