wrong 0.4.0-java

data/test/message/test_context_test.rb

@@ -0,0 +1,69 @@
+require "./test/test_helper"
+require "wrong/assert"
+require "wrong/message/test_context"
+
+xdescribe "showing the lines just above where the failure occurs, so you have some context" do
+
+  include Wrong::Assert
+  
+  it "you can see test method all the way back to the start of the test, plus an indication of where the failure was" do
+    a = 1
+    b = 2
+    c = 1
+    assert{ a == c }
+    begin
+      assert{ a == b }
+    rescue Wrong::Assert::AssertionFailedError => e
+      puts e
+      assert do
+        e.message.include?(
+%{  it "you can see test method all the way back to the start of the test, plus an indication of where the failure was" do
+    a = 1
+    b = 2
+    c = 1
+    assert{ a == c }
+    begin
+      assert{ a == b }      ASSERTION FAILURE test/include_test_context_test.rb:15}
+        )
+      end
+      
+      deny {e.message.include?("works with it too")}
+      deny {e.message.include?("test_works_with_test_undercore")}
+    end
+  end
+  
+  it "works with it too" do
+    begin
+      assert{ 1 == 2 }
+    rescue Wrong::Assert::AssertionFailedError => e
+      assert do
+        e.message.include?(
+%{  it "works with it too" do
+    begin
+      assert{ 1 == 2 }      ASSERTION FAILURE test/include_test_context_test.rb:36}
+        )
+      end
+      
+      deny {e.message.include?("you can see test method")}
+      deny {e.message.include?("test_works_with_test_undercore")}
+    end
+  end
+  
+  def test_works_with_test_undercore_too
+    begin
+      assert{ 1 == 2 }
+    rescue Wrong::Assert::AssertionFailedError => e
+      assert do
+        e.message.include?(
+%{  def test_works_with_test_undercore_too
+    begin
+      assert{ 1 == 2 }      ASSERTION FAILURE test/include_test_context_test.rb:53}
+        )
+      end
+      
+      deny {e.message.include?("you can see test method")}
+      deny {e.message.include?("works with it too")}
+    end
+  end
+  
+end

data/test/rescuing_test.rb

@@ -0,0 +1,17 @@
+require "./test/test_helper"
+require "wrong/adapters/minitest"
+
+describe "a helper for rescuing errors" do
+  
+  class RedError < StandardError; end
+  class BlueError < StandardError; end
+  
+  it "returns the error that was raised" do
+    assert{ rescuing{raise RedError.new}.is_a?(RedError) }
+  end
+
+  it "returns nil if nothing was raised" do
+    assert{ rescuing{"x"}.nil? }
+  end
+  
+end

data/test/separate.rb

@@ -0,0 +1,4 @@
+#simple (but slow) way to make sure requires are isolated
+result = Dir["test/**/*_test.rb"].collect{|test_file| system("bundle exec ruby #{test_file}") }.uniq == [true]
+puts "suite " + (result ? "passed" : "FAILED")
+exit(result ? 0 : 1)

data/test/sexp_ext_test.rb

@@ -0,0 +1,80 @@
+require "./test/test_helper"
+require "wrong/sexp_ext"
+
+describe Sexp do
+  describe "#deep_clone" do
+    it "deeply duplicates the sexp" do
+      original = RubyParser.new.parse("x == 5")
+      duplicate = original.deep_clone
+      assert(original.object_id != duplicate.object_id)
+      assert(original[1].object_id != duplicate[1].object_id)
+      assert(original[1][3].object_id != duplicate[1][3].object_id)
+      assert(original[3].object_id != duplicate[3].object_id)
+    end
+  end
+
+  def parse(ruby)
+    RubyParser.new.parse(ruby)
+  end
+
+  describe "#to_ruby" do
+    it "converts the sexp to ruby code" do
+      sexp = parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+    end
+
+    it "leaves the original sexp alone" do
+      sexp = parse("x == 5")
+      assert sexp.to_ruby == "(x == 5)"
+      assert sexp.to_ruby == "(x == 5)" # intended
+    end
+  end
+
+  describe "#assertion? with a question mark" do
+    it "matches an sexp that looks like assert { }" do
+      sexp = parse("assert { true }")
+      assert sexp.assertion?
+    end
+
+    it "matches an sexp that looks like assert(message) { }" do
+      sexp = parse("assert('hi') { true }")
+      assert sexp.assertion?
+    end
+
+    it "matches an sexp that looks like deny { }" do
+      sexp = parse("deny { false }")
+      assert sexp.assertion?
+    end
+
+    it "doesn't match an sexp that calls assert without a block" do
+      sexp = parse("assert(true)")
+      assert !sexp.assertion?
+    end
+
+    it "doesn't match a normal sexp" do
+      sexp = parse("x == 5")
+      assert !sexp.assertion?
+    end
+  end
+
+  describe "#assertion" do
+    it "matches a top-level sexp that looks like assert { }" do
+      sexp = parse("assert { true }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+
+    it "matches a nested sexp that looks like assert { }" do
+      sexp = parse("nesting { assert { true } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+
+    it "matches the first nested sexp that looks like assert { }" do
+      sexp = parse("nesting { assert { true } or assert { false } }")
+      code = sexp.assertion.to_ruby
+      assert code == "assert { true }"
+    end
+  end
+
+end

data/test/string_comparison_test.rb

@@ -0,0 +1,159 @@
+require "./test/test_helper"
+require "wrong/adapters/minitest"
+require "wrong/message/string_comparison"
+
+module Wrong
+describe StringComparison do
+
+  before do
+    # crank the window and prelude down for these tests
+    @old_window = StringComparison.window
+    @old_prelude = StringComparison.prelude
+    StringComparison.window = 16
+    StringComparison.prelude = 8
+  end
+
+  after do
+    StringComparison.window = @old_window
+    StringComparison.prelude = @old_prelude
+  end
+
+  describe '#same?' do
+    it "says identical empty strings are the same" do
+      comparison = StringComparison.new("", "")
+      assert { comparison.same? }
+    end
+
+    it "says identical non-empty strings are the same" do
+      comparison = StringComparison.new("abc", "abc")
+      assert { comparison.same? }
+    end
+
+    it "says two nils are the same" do
+      comparison = StringComparison.new(nil, nil)
+      assert { comparison.same? }
+    end
+
+    it "says a string is different from a different string" do
+      comparison = StringComparison.new("abc", "xyz")
+      deny { comparison.same? }
+    end
+
+    it "says a string is different from nil" do
+      comparison = StringComparison.new("abc", nil)
+      deny { comparison.same? }
+    end
+
+    it "says nil is different from a string" do
+      comparison = StringComparison.new(nil, "abc")
+      deny { comparison.same? }
+    end
+  end
+
+  describe '#different_at' do
+    describe "returns the location where two strings differ" do
+
+      it "at the beginning of the strings" do
+        assert { StringComparison.new("abc", "xyz").different_at == 0 }
+      end
+
+      it "at the middle of the strings" do
+        assert { StringComparison.new("abc", "ayz").different_at == 1 }
+      end
+
+      it "when the first string is longer" do
+        assert { StringComparison.new("abcd", "abc").different_at == 3 }
+      end
+
+      it "when the second string is longer" do
+        assert { StringComparison.new("abc", "abcd").different_at == 3 }
+      end
+
+      it "with nil as the first string" do
+        assert { StringComparison.new(nil, "abc").different_at == 0 }
+      end
+
+      it "with nil as the second string" do
+        assert { StringComparison.new("abc", nil).different_at == 0 }
+      end
+
+    end
+  end
+
+  describe '#message' do
+    def compare(first, second, expected_message)
+      expected_message.strip!
+      assert { StringComparison.new(first, second).message == expected_message }
+    end
+
+    it 'shows the whole of both strings when the difference is near the start' do
+compare "abc", "xyz", <<-MESSAGE
+Strings differ at position 0:
+ first: "abc"
+second: "xyz"
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is in the middle of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijkl*nopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 12:
+ first: ..."efghijklmnopqrst"...
+second: ..."efghijkl*nopqrst"...
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is near the beginning of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "a*cdefghijklmnopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 1:
+ first: "abcdefghijklmnop"...
+second: "a*cdefghijklmnop"...
+      MESSAGE
+    end
+
+    it 'shows ellipses when the difference is near the end of a long string' do
+      compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvw*yz", <<-MESSAGE
+Strings differ at position 23:
+ first: ..."pqrstuvwxyz"
+second: ..."pqrstuvw*yz"
+      MESSAGE
+    end
+
+    it 'allows user to override the default window size' do
+      original = StringComparison.window
+      begin
+        StringComparison.window = 10
+        compare "abcdefghijklmnopqrstuvwxyz", "a*cdefghijklmnopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 1:
+ first: "abcdefghij"...
+second: "a*cdefghij"...
+        MESSAGE
+      ensure
+        StringComparison.window = original
+      end
+    end
+
+    it 'allows user to override the prelude size' do
+      original = StringComparison.prelude
+      begin
+        StringComparison.prelude = 2
+        compare "abcdefghijklmnopqrstuvwxyz", "abcdefghijkl*nopqrstuvwxyz", <<-MESSAGE
+Strings differ at position 12:
+ first: ..."klmnopqrstuvwxyz"
+second: ..."kl*nopqrstuvwxyz"
+        MESSAGE
+      ensure
+        StringComparison.prelude = original
+      end
+    end
+  end
+  end
+
+  describe "Wrong integration" do
+    it "works" do
+      error = rescuing do
+        assert { "xyz" == "abc" }
+      end
+      assert { error.message =~ /Strings differ/ }
+    end
+  end
+end

data/test/suite.rb

@@ -0,0 +1,7 @@
+#simple (but slow) way to make sure requires are isolated
+failed = Dir["test/**/*_test.rb"].collect do |test_file|
+  ok = system("bundle exec ruby #{test_file}")
+  test_file unless ok
+end.compact
+puts "suite " + (failed.empty? ? "passed" : "FAILED: #{failed.join(', ')}")
+exit(failed.empty? ? 0 : 1)

data/test/test_helper.rb

@@ -0,0 +1,64 @@
+puts "RUBY_VERSION=#{RUBY_VERSION}#{" (JRuby)" if Object.const_defined?(:JRuby)}"
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+
+predicated_project_dir = File.expand_path("../predicated")
+if File.exist?(predicated_project_dir) # if predicated project is a sibling of this project
+  puts "using predicated from #{predicated_project_dir}"
+  $LOAD_PATH.unshift "#{predicated_project_dir}/lib"
+  require "predicated"
+end
+
+require "rubygems"
+require "minitest/spec"
+require "minitest/unit"
+require "pp"
+
+# yes, this does look a lot like Wrong::Assert#rescuing :-)
+def get_error
+  error = nil
+  begin
+    yield
+  rescue Exception, RuntimeError => e
+    error = e
+  end
+  error
+end
+
+class MiniTest::Unit::TestCase
+end
+
+module Kernel
+  def xdescribe(str)
+    puts "x'd out describe \"#{str}\""
+  end
+end
+
+class MiniTest::Spec
+  include MiniTest::Assertions
+  
+  class << self
+    def xit(str)
+      puts "x'd out test \"#{str}\""
+    end
+  end
+end
+
+# dummy class for use by tests
+class Color
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    other.is_a?(Color) && @name == other.name
+  end
+
+  def inspect
+    "Color:#{@name}"
+  end
+end
+
+MiniTest::Unit.autorun

data/test/wrong_test.rb

@@ -0,0 +1,60 @@
+require "./test/test_helper"
+require "wrong"
+
+describe "the Wrong module" do
+
+  class Client
+    include Wrong
+  end
+
+  describe "by itself" do
+    it "gets the assert method" do
+      Wrong.assert { true }
+    end
+
+    it "gets the deny method" do
+      Wrong.deny { false }
+    end
+
+    it "gets the capturing method" do
+      value = Wrong.capturing { puts "ok" }
+      assert value == "ok\n"
+    end
+
+    it "gets the rescuing method" do
+      value = Wrong.rescuing { raise "uh-oh" }
+      assert value.message == "uh-oh"
+    end
+
+  end
+
+  describe "when included" do
+    it "gets the assert method" do
+      Client.new.assert { true }
+    end
+
+    it "gets the deny method" do
+      Client.new.deny { false }
+    end
+
+    it "gets the capturing method" do
+      value = Client.new.capturing { puts "ok" }
+      assert value == "ok\n"
+    end
+
+    it "gets the rescuing method" do
+      value = Client.new.rescuing { raise "uh-oh" }
+      assert value.message == "uh-oh"
+    end
+
+    it "adds #close_to? to Float" do
+      assert 1.0.respond_to?(:close_to?)
+    end
+
+    it "adds #d to a global namespace" do
+      x = 5
+      output = Wrong.capturing { d { x } }
+      Wrong.assert { output == "x is 5\n" }
+    end
+  end
+end