wrong 0.4.0-java

data/test/close_to_test.rb

@@ -0,0 +1,39 @@
+require "./test/test_helper"
+require "wrong/close_to"
+require "wrong"
+
+describe "#close_to? (monkey patch for float comparison)" do
+  include Wrong
+
+  it "says two equal floats are equal" do
+    assert { 5.0.close_to? 5.0 }
+  end
+
+  it "says two unequal floats are unequal" do
+    deny { 5.0.close_to? 6.0 }
+  end
+
+  it "has a default tolerance of 0.001" do
+    assert { 5.0.close_to? 5.0001 }
+    assert { 5.0.close_to? 5.0009 }
+    deny   { 5.0.close_to? 5.001 }
+    deny   { 5.0.close_to? 5.01 }
+  end
+
+  it "takes a tolerance parameter" do
+    assert { 5.0.close_to? 5.01, 0.1 }
+  end
+
+  it "excludes the tolerance maximum" do
+    assert { 5.0.close_to? 5.9999, 1.0 }
+    deny   { 5.0.close_to? 6.00, 1.0 }
+  end
+
+  it "works for integers too" do
+    assert { 5.close_to? 5 }
+    assert { 5.close_to? 5.0001 }
+    deny   { 5.close_to? 5.1 }
+    assert { 5.close_to? 5.1, 0.5 }
+  end
+
+end

data/test/config_test.rb

@@ -0,0 +1,89 @@
+require "./test/test_helper"
+
+require "wrong"
+require "wrong/config"
+require "wrong/message/string_comparison"
+
+describe Wrong::Config do
+
+  # hope this doesn't blow up, but I'll try to use Wrong to test the Config object
+  include Wrong
+
+  before do
+    Wrong.config.clear
+  end
+
+  it "singleton" do
+    c = Wrong.config
+    assert { c.is_a?(Wrong::Config) }
+    c2 = Wrong.config
+    assert { c.object_id == c2.object_id }
+  end
+
+#  it "reads from a .wrong file"
+
+  it "getting an undeclared setting" do
+    assert { Wrong.config[:foo].nil? }
+  end
+
+  it "setting and getting" do
+    Wrong.config[:foo] = "bar"
+    assert { Wrong.config[:foo] == "bar" }
+  end
+
+  describe "adding aliases for assert" do
+    before do
+      Wrong.config.alias_assert(:is)
+    end
+
+    it "succeeds" do
+      is { 2 + 2 == 4 }
+    end
+
+    it "fails" do
+      e = rescuing {
+        is("math is hard") { 2 + 2 == 5 }
+      }
+      expected = <<-FAIL
+math is hard: Expected ((2 + 2) == 5), but 4 is not equal to 5
+    (2 + 2) is 4
+      FAIL
+      assert { e.message == expected }
+    end
+
+    it "doesn't keep aliasing the same word" do
+      Wrong.config.alias_assert(:is)
+      Wrong.config.alias_assert(:is)
+      assert { Wrong.config.assert_method_names == [:assert, :is] } 
+    end
+  end
+
+  describe "adding aliases for deny" do
+    before do
+      Wrong.config.alias_deny(:aint)
+    end
+
+    it "succeeds" do
+      aint { 2 + 2 == 5 }
+    end
+
+    it "fails" do
+      e = rescuing {
+        aint("math is hard") { 2 + 2 == 4 }
+      }
+      expected = <<-FAIL
+math is hard: Didn't expect ((2 + 2) == 4), but 4 is equal to 4
+    (2 + 2) is 4
+      FAIL
+      assert { e.message == expected }
+    end
+
+    it "doesn't keep aliasing the same word" do
+      Wrong.config.alias_deny(:aint)
+      Wrong.config.alias_deny(:aint)
+      assert { Wrong.config.deny_method_names == [:deny, :aint] }
+    end
+
+  end
+
+end

data/test/d_test.rb

@@ -0,0 +1,64 @@
+require "./test/test_helper"
+require "wrong"
+require "wrong/d"
+require "wrong/adapters/minitest"
+
+describe "d" do
+  include Wrong::D
+
+  it "prints its argument's name and its value" do
+    x = 5
+    output = capturing do
+      d { x }
+    end
+    assert { output == "x is 5\n" }
+  end
+
+  it "inspects the value" do
+    x = "one\ttwo"
+    output = capturing do
+      d { x }
+    end
+    assert { output == "x is \"one\\ttwo\"\n" }
+  end
+
+  it "works on an expression" do
+    x = 5
+    output = capturing do
+      d { x + 2 }
+    end
+    assert { output == "(x + 2) is 7\n" }
+  end
+
+  it "works even if it's not the only thing on the line" do
+    x = 8
+    output = capturing do
+      x; d { x }
+    end
+    assert { output == "x is 8\n" }
+  end
+
+  it "works even if it's nested in another block on the same line" do
+    x = 8
+    output = capturing do
+      assert { d { x }; true }
+    end
+    assert { output == "x is 8\n" }
+  end
+
+  it "works when called on an extending module" do
+    module Something
+      extend Wrong::D
+    end
+    x = 99
+    output = capturing { Something.d { x }}
+    assert { output == "x is 99\n" }
+  end
+
+  it "works when called on the D module" do
+    x = 9
+    output = capturing { Wrong::D.d { x }}
+    assert { output == "x is 9\n" }
+  end
+
+end

data/test/failure_message_test.rb

@@ -0,0 +1,40 @@
+require "./test/test_helper"
+require "wrong/assert"
+require "wrong/failure_message"
+
+module Wrong
+
+  class BogusFormatter < FailureMessage::Formatter
+    def match?
+      predicate.is_a? BogusPredicate
+    end
+
+    def describe
+      "bogus #{predicate.object_id}"
+    end
+  end
+
+  class BogusPredicate < Predicated::Predicate
+  end
+
+  describe FailureMessage::Formatter do
+    include Wrong::Assert
+
+    it "describes a predicate" do
+      predicate = BogusPredicate.new
+      formatter = BogusFormatter.new(predicate)
+      assert { formatter.describe == "bogus #{predicate.object_id}" }
+    end
+  end
+
+  describe FailureMessage do
+    include Wrong::Assert
+
+    it "can register a formatter class for a predicate pattern" do
+      FailureMessage.register_formatter(BogusFormatter)
+      assert { FailureMessage.formatter_for(BogusPredicate.new).is_a? BogusFormatter }
+      assert { FailureMessage.formatters.include?(BogusFormatter)}
+    end
+
+  end
+end

data/test/failures_test.rb

@@ -0,0 +1,157 @@
+require "./test/test_helper"
+
+require "wrong/assert"
+
+describe "failures" do
+
+  before do
+    @m = Module.new do
+      extend Wrong::Assert
+    end
+  end
+
+  describe "simple" do
+
+    it "raw boolean assert failure" do
+      error = get_error { @m.assert { false } }
+      assert_match "false", error.message
+    end
+
+    it "raw boolean deny failure" do
+      error = get_error {
+        @m.deny { true }
+      }
+      assert_match "true", error.message
+    end
+
+    it "equality failure" do
+      assert_match "1 is not equal to 2", get_error {
+        @m.assert { 1==2 }
+      }.message
+      assert_match "1 is equal to 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 {
+        @m.assert {
+          1==
+                  2
+        }
+      }.message)
+    end
+
+  end
+
+  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 {
+        @m.assert { a==2 }
+      }.message
+      assert_match "1 is equal to 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 "array comparisons" do
+    it "basic" do
+      assert_match %{[1, 2] is not equal to ["a", "b"]}, get_error {
+        @m.assert { [1, 2]==%w{a b} }
+      }.message
+    end
+  end
+
+  describe "hash comparisons" do
+    it "basic" 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
+    end
+  end
+
+end

data/test/message/array_diff_test.rb

@@ -0,0 +1,79 @@
+require "./test/test_helper"
+require "wrong/assert"
+require "wrong/helpers"
+require "wrong/adapters/minitest"
+
+require "wrong/message/array_diff"
+
+describe "when you're comparing strings and they don't match, show me the diff message" do
+
+  def assert_string_diff_message(first_array, second_array, expected_error_message)
+    e = rescuing {
+      Wrong.assert { first_array == second_array }
+    }
+    assert {
+      e.message.include?(expected_error_message.strip)
+    }
+  end
+
+  it "don't attempt to do this if the assertion is not of the form a_array==b_array" do
+    deny {
+      rescuing {
+        assert { [1]==2 }
+      }.message.include?("^")
+    }
+    deny {
+      rescuing {
+        assert { nil==[1] }
+      }.message.include?("^")
+    }
+  end
+
+  it "simple" do
+    e = rescuing {
+      assert { ["a"]==["b"] }
+    }
+    assert {
+      e.message.include?("^")
+    }
+
+    assert_string_diff_message(["a", "b"], ["a", "c", "c"], %{
+["a", "b"]
+["a", "c", "c"]
+      ^    ^
+})
+  end
+
+  it "elements align properly" do
+    assert_string_diff_message(["a", "b", "c"], ["a", "cccc", "c"], %{
+["a", "b"   , "c"]
+["a", "cccc", "c"]
+      ^
+})
+
+    assert_string_diff_message(["a", "b", "c", "d"], ["a", "cccc", "xxx", "d"], %{
+["a", "b"   , "c"  , "d"]
+["a", "cccc", "xxx", "d"]
+      ^       ^
+})
+  end
+
+  it "different primitive types" do
+    assert_string_diff_message([1, true], [2, true, nil], %{
+[1, true]
+[2, true, nil]
+ ^        ^
+})
+  end
+
+  it "2d array - just inspects the inner array like it would any other element" do
+    assert { [1, [2, 3]] == [1, [2, 3]] }
+    assert_string_diff_message([1, [2]], [1, [2, 3]], %{
+[1, [2]   ]
+[1, [2, 3]]
+    ^
+})
+
+  end
+
+end