wrong 0.4.0-java

data/test/adapters/rspec1/failing_spec.rb

@@ -0,0 +1,23 @@
+# This is a failing spec for testing RSpec 1.3 integration
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require "spec"
+
+here = File.expand_path(File.dirname(__FILE__))
+$:.unshift "#{here}/../../../lib"
+require "wrong/adapters/rspec"
+
+# since we're not running 'spec' we have to do some stuff ourselves
+include Spec::DSL::Main
+
+describe "arithmetic" do
+  it "should not work like this" do
+    assert { 2 + 2 == 5 }
+  end
+end
+
+Spec::Runner.options.parse_format("nested")
+Spec::Runner.options.run_examples

data/test/adapters/rspec2/failing_spec.rb

@@ -0,0 +1,26 @@
+# This is a failing spec for testing RSpec 2 integration
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require "rspec"
+
+here = File.expand_path(File.dirname(__FILE__))
+$:.unshift "#{here}/../../../lib"
+
+# since we're not running 'rspec' we have to do some stuff ourselves
+require 'rspec'
+require 'rspec/core'
+puts RSpec::Core::Version::STRING
+
+require 'rspec/autorun'
+require "wrong/adapters/rspec"
+
+describe "arithmetic" do
+  it "should not work like this" do
+    assert { 2 + 2 == 5 }
+  end
+end
+
+# now, thanks to the require 'rspec/autorun', this spec will run and fail

data/test/adapters/rspec_test.rb

@@ -0,0 +1,104 @@
+here = File.expand_path(File.dirname(__FILE__))
+
+require "open3"
+require "fileutils"
+
+require "./test/test_helper"
+require "wrong/adapters/minitest"
+
+include Wrong
+
+# Okay, this looks like RSpec but it's actually minitest
+describe "testing rspec" do
+
+  def sys(cmd, expected_status = 0)
+    start_time = Time.now
+    $stderr.print cmd
+    Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thread|
+      # in Ruby 1.8, wait_thread is nil :-( so just pretend the process was successful (status 0)
+      exit_status = (wait_thread.value.exitstatus if wait_thread) || 0
+      output = stdout.read + stderr.read
+      unless expected_status.nil?
+        assert { output and exit_status == expected_status }
+      end
+      yield output if block_given?
+      output
+    end
+  ensure
+    $stderr.puts " (#{"%.2f" % (Time.now - start_time)} sec)"
+  end
+
+  def clear_bundler_env
+    # Bundler inherits its environment by default, so clear it here
+    %w{BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE}.each { |var| ENV.delete(var) }
+  end
+
+  [1, 2].each do |rspec_version|
+    it "version #{rspec_version}" do
+      dir = "#{here}/rspec#{rspec_version}"
+      spec_output = nil
+      Dir.chdir(dir) do
+        clear_bundler_env
+        FileUtils.rm "#{dir}/Gemfile.lock", :force => true
+
+        sys "bundle check" do |output|
+          unless output == "The Gemfile's dependencies are satisfied\n"
+            sys "bundle install --gemfile=#{dir}/Gemfile --local"
+          end
+        end
+
+        sys "bundle list" do |output|
+          lines = output.split("\n")
+          lines.grep(/rspec/) do |line|
+            assert { line =~ /rspec[-\w]* \(#{rspec_version}\.[\w.]*\)/ }
+          end
+        end
+
+        spec_output = sys "ruby #{dir}/failing_spec.rb",
+                          (rspec_version == 1 || RUBY_VERSION =~ /^1\.8\./ || RUBY_VERSION == '1.9.1' ? nil : 1) # RSpec v1 exits with 0 on failure :-(
+      end
+
+      assert { spec_output.include? "1 example, 1 failure" }
+      assert { spec_output.include? "Expected ((2 + 2) == 5), but" }
+    end
+  end
+end
+
+=begin
+    # I would use
+    #    out, err = capturing(:stdout, :stderr) do
+    # but minitest does its own arcane stream munging and it's not working
+
+    out = StringIO.new
+    err = StringIO.new
+    Spec::Runner.use(Spec::Runner::Options.new(out, err))
+
+    module RSpecWrapper
+      include Spec::DSL::Main
+      describe "inside rspec land" do
+        it "works" do
+          sky = "blue"
+          assert { sky == "green" }
+        end
+      end
+    end
+
+    Spec::Runner.options.parse_format("nested")
+    Spec::Runner.options.run_examples
+
+    assert(err.string.index(<<-RSPEC) == 0, "make sure the rspec formatter was used")
+inside rspec land
+  works (FAILED - 1)
+
+1)
+'inside rspec land works' FAILED
+    RSPEC
+
+    failures = Spec::Runner.options.reporter.instance_variable_get(:@failures) # todo: use my own reporter?
+    assert !failures.empty?
+    exception = failures.first.exception
+    assert(exception.is_a?(Spec::Expectations::ExpectationNotMetError))
+    assert(exception.message =~ /^Expected \(sky == \"green\"\), but/, "message is #{exception.message.inspect}")
+  end
+end
+=end

data/test/adapters/test_unit_test.rb

@@ -0,0 +1,59 @@
+require "./test/test_helper"
+
+require "test/unit"
+
+#require "wrong/assert"
+require "wrong/adapters/test_unit"
+
+# get rid of atrocious Test::Unit color scheme (gray on green = puke)
+Test::Unit::AutoRunner.setup_option do |auto_runner, opts|
+  auto_runner.runner_options[:use_color] = false
+end
+
+class MyFailingAssertTest <  Test::Unit::TestCase
+
+  def test_wrong_assert_and_deny_are_available_to_test_unit_tests
+    my_failing_assert_test = Class.new(Test::Unit::TestCase)
+    my_failing_assert_test.class_eval do
+      def test_fail
+        assert{1==2}
+      end
+    end
+    
+    my_failing_deny_test = Class.new(Test::Unit::TestCase)
+    my_failing_deny_test.class_eval do
+      def test_fail
+        deny{1==1}
+      end
+    end
+    
+    result = Test::Unit::TestResult.new
+    my_failing_assert_test.new("test_fail").run(result) {|started, name| }
+    #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") }
+    
+    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") }
+  end
+
+  def test_passes_asserts_with_no_block_up_to_the_frameworks_assert_method
+    e = rescuing { assert(1 == 2) }
+    assert { e.message == "<false> is not true." }
+
+    e = rescuing { assert(1 == 2, "black is white") }
+    assert { e.message == "black is white.\n<false> is not true." }
+  end
+
+  def test_passes_denys_with_no_block_up_to_the_frameworks_assert_method
+    e = rescuing { deny(2 + 2 == 4) }
+    assert { e.message == "<false> is not true." }
+
+    e = rescuing { deny(2 + 2 == 4, "up is down") }
+    assert { e.message == "up is down.\n<false> is not true." }
+  end
+end

data/test/assert_advanced_test.rb

@@ -0,0 +1,51 @@
+require "./test/test_helper"
+require "wrong/assert"
+require "wrong/adapters/minitest"
+
+describe "advanced assert features" do
+
+  def assert_later(&p)
+    assert(&p)
+  end
+
+  # dunno why, but this fails under JRuby (both 1.8 and 1.9)
+  unless Object.const_defined? :JRuby
+    it "is possible (but hardly advisable) to define procs in different places from the assert call" do
+      x = 10
+      e = get_error do
+        assert_later { x > 10 }
+      end
+
+      assert(e.message =~ /Expected \(x > 10\), but.*x is 10/m, e.message)
+    end
+  end
+
+  xit "can parse a here doc defined inside the block" do
+    # todo: test in Chunk too
+    assert { "123\n456" == <<-TEXT
+123
+456
+    TEXT
+    }
+  end
+
+  xit "can parse a here doc defined outside the block" do
+    # todo: test in Chunk too
+    assert { "123\n456" == <<-TEXT }
+123
+456
+    TEXT
+  end
+
+  it "finds the file to parse even when inside a chdir to a child directory" do
+    e = get_error do
+      Dir.chdir("test") do
+        assert { (1 + 2) == 5 }
+      end
+    end
+    assert { e.message.include? "Expected ((1 + 2) == 5), but" }
+  end
+
+  # todo: test for finding it if you'd changed dirs into a parent or sibling or cousin dir
+
+end

data/test/assert_test.rb

@@ -0,0 +1,76 @@
+require "./test/test_helper"
+require "wrong/assert"
+
+describe "basic assert features" do
+
+  before do
+    @m = Module.new do
+      extend Wrong::Assert
+    end
+  end
+
+  describe "pass/fail basics" do
+    it "passes when the result is true.  deny does the reverse" do
+      @m.assert { true }
+      @m.assert { 1==1 }
+
+      @m.deny { false }
+      @m.deny { 1==2 }
+    end
+
+    it "fails when result is false.  deny does the reverse" do
+      get_error {
+        @m.assert { false }
+      } || fail
+      get_error {
+        @m.assert { 1==2 }
+      } || fail
+
+      get_error {
+        @m.deny { true }
+      } || fail
+      get_error {
+        @m.deny { 1==1 }
+      } || fail
+    end
+
+    class MyError < StandardError;
+    end
+
+    describe "assert" do
+      it "fails when an error is thrown and bubbles up the error" do
+        assert_raises(MyError) { @m.assert { raise MyError.new } }
+      end
+
+      it "takes an optional explanation" do
+        e = get_error {
+          sky = "green"
+          @m.assert("the sky should be blue") { sky == "blue" }
+        }
+        assert e.message =~ /^the sky should be blue: /, e.message
+      end
+
+      it "gives a meaningful error when passed no block" do
+        e = get_error {
+          @m.assert(2+2 == 5)
+        }
+        assert e.message =~ /a block/, e.message
+      end
+    end
+
+    describe "deny" do
+      it "fails when an error is thrown and bubbles up the error" do
+        assert_raises(MyError) { @m.deny { raise MyError.new } }
+      end
+
+      it "takes an optional explanation" do
+        e = get_error {
+          sky = "blue"
+          @m.deny("the sky should not be blue") { sky == "blue" }
+        }
+        assert e.message =~ /^the sky should not be blue: /,
+               e.message + "\n\t" + e.backtrace.join("\n\t")
+      end
+    end
+  end
+end

data/test/capturing_test.rb

@@ -0,0 +1,59 @@
+require "./test/test_helper"
+
+require "wrong/assert"
+require "wrong/helpers"
+
+describe "a tool for capturing output" do
+
+  include Wrong::Assert
+  include Wrong::Helpers
+
+  it "captures stdout" do
+    assert {
+      capturing { puts "hi" } == "hi\n"
+    }
+  end
+
+  it "captures stderr" do
+    assert {
+      capturing(:stderr) { $stderr.puts "hi" } == "hi\n"
+    }
+  end
+
+  it "captures both" do
+    out, err = capturing(:stdout, :stderr) do
+       $stdout.puts "hi"
+       $stderr.puts "bye"
+    end
+
+    assert { out == "hi\n"}
+    assert { err == "bye\n"}
+
+  end
+
+  it "supports nesting" do
+    inside = nil
+    outside = capturing do
+      puts "bread"
+      inside = capturing do
+        puts "ham"
+      end
+      puts "more bread"
+    end
+
+    assert { inside == "ham\n"}
+    assert { outside == "bread\nham\nmore bread\n"}
+  end
+
+
+  it "bails if stream was reassigned" do
+    e = rescuing do
+      capturing do
+        $stdout = StringIO.new # uh-oh!
+      end
+    end
+    assert { e.message =~ /^stdout was reassigned/ }
+  end
+
+
+end

data/test/chunk_test.rb

@@ -0,0 +1,264 @@
+require "./test/test_helper"
+require "wrong/chunk"
+
+unless Object.const_defined?(:Chunk)
+  Chunk = Wrong::Chunk
+end
+
+describe Chunk do
+  describe "#from_block" do
+    it "reads the source location" do
+      file, line = __FILE__, __LINE__
+      chunk = Chunk.from_block(proc { "hi" })
+      assert(chunk.file == file)
+      assert(chunk.line_number == line+1)
+    end
+  end
+
+  describe "line numbers" do
+    before do
+      @chunk = Wrong::Chunk.new("foo.rb", 10)
+    end
+    it "#line_index is zero-based" do
+      assert(@chunk.line_index == 9)
+    end
+    it "#location is one-based" do
+      assert(@chunk.location == "foo.rb:10")
+    end
+  end
+
+  describe "parsing" do
+    it "reads a statement on a line by itself" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi"
+      CODE
+      code = chunk.sexp.to_ruby
+      assert(code == '"hi"')
+    end
+
+    it "reads a statement on multiple lines" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        proc do
+          "hi"
+        end
+      CODE
+      code = chunk.sexp.to_ruby
+      assert(code == "proc { \"hi\" }")
+    end
+
+    it "fails if there's a stray close-paren symbol on the last line (sorry)" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi" )
+      CODE
+      assert(chunk.sexp.nil?)
+    end
+
+    it "fails if there's a stray close-block symbol on the last line (sorry)" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        "hi" }
+      CODE
+      assert(chunk.sexp.nil?)
+    end
+
+    it "fails if it can't parse the code" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        }
+      CODE
+      assert(chunk.sexp.nil?)
+    end
+
+    it "fails if it can't find the file" do
+      chunk = Chunk.new("nonexistent_file.rb", 0)
+      error = get_error { chunk.sexp }
+      assert error.is_a? Errno::ENOENT
+    end
+
+    it "finds the file to parse even when inside a chdir to a child directory" do
+      Dir.chdir("test") do
+        chunk = Chunk.new __FILE__, __LINE__ + 1; <<-CODE
+        "hi"
+        CODE
+        code = chunk.sexp.to_ruby
+        assert(code == '"hi"')
+      end
+    end
+  end
+
+  describe "#claim" do
+    it "returns the part of the assertion statement inside the curly braces" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { x == 5 }
+      CODE
+      full_code = chunk.sexp.to_ruby
+      assert(full_code == "assert { (x == 5) }")
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+
+    it "reads an assert statement on a line by itself" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { x == 5 }
+      CODE
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+    it "reads an assert statement on multiple lines" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert do
+           x == 5
+        end
+      CODE
+      claim_code = chunk.claim.to_ruby
+      assert claim_code == "(x == 5)"
+    end
+
+    def yielding
+      yield
+    end
+
+    if RUBY_VERSION > "1.9"
+      it "reads an assert statement that's nested inside another yield block on the same line (Ruby 1.9 only)" do
+        chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+          yielding { assert { x == 5 }}
+        CODE
+        code = chunk.claim.to_ruby
+        assert code == "(x == 5)"
+      end
+
+#      test "goes crazy if you try to nest two asserts on the same line"
+    end
+
+    it "if it can't find an assertion, it uses the whole chunk" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        yielding { x == 5 }
+      CODE
+      code = chunk.claim.to_ruby
+      assert code == "yielding { (x == 5) }"
+    end
+
+    it "fails if it can't parse the code" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        }
+      CODE
+      error = get_error {
+        chunk.claim
+      }
+      assert error.message.include?("Could not parse")
+    end
+  end
+
+  describe "#parts" do
+    it "returns all unique sub-expressions of the main sexpression" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { (x == 5) && (y == (z + 10)) }
+      CODE
+      code_parts = chunk.parts
+      assert code_parts == <<-PARTS.split("\n")
+((x == 5) and (y == (z + 10)))
+(x == 5)
+x
+5
+(y == (z + 10))
+y
+(z + 10)
+z
+10
+      PARTS
+    end
+
+    it "omits the method-call-sans-block part of a method call with a block" do
+      chunk = Chunk.new(__FILE__, __LINE__ + 1); <<-CODE
+        assert { rescuing { 1 + 2 } }
+      CODE
+      code_parts = chunk.parts
+      assert !code_parts.include?("rescuing")
+    end
+  end
+
+  describe "#details" do
+    def details(&block)
+      chunk = Chunk.from_block(block, 1)
+      d = chunk.details
+#      puts d
+      d
+    end
+
+    it "returns an empty string if there are no parts" do
+      d = details { assert { true } }
+      assert d == ""
+    end
+
+    it "returns an string beginning with a newline if there are parts" do
+      x = 10
+      d = details { assert { x == 10 } }
+      assert d == "\n    x is 10\n"
+    end
+
+    it "skips literals" do
+      d = details { assert { 10 == 11 } }
+      assert d == ""
+    end
+
+    it "shows lots of details" do
+      x = 10
+      d = details { assert { (x * (x - 10)) == (x / (x + 10)) } }
+      assert d == <<-DETAILS
+
+    (x * (x - 10)) is 0
+    x is 10
+    (x - 10) is 0
+    (x / (x + 10)) is 0
+    (x + 10) is 20
+      DETAILS
+    end
+
+    it "skips duplicates" do
+      x = 10
+      d = details { assert { (x + 5) == 1 + (x + 5) } }
+      assert d == <<-DETAILS
+
+    (x + 5) is 15
+    x is 10
+    (1 + (x + 5)) is 16
+      DETAILS
+    end
+
+    it "shows exceptions" do
+      d = details { assert { (raise "hi") == 1 } }
+      assert d == "\n    raise(\"hi\") raises RuntimeError: hi\n"
+    end
+
+    it "indents newlines inside the exception message" do
+      d = details { assert { (raise "hello\nsailor") == 1 } }
+      assert d == "\n    raise(\"hello\\nsailor\") raises RuntimeError: hello\n      sailor\n"
+    end
+
+    it "abridges exceptions with no message" do
+      d = details { assert { (raise Exception.new) == 1 } }
+      assert d == "\n    raise(Exception.new) raises Exception\n" +
+              "    Exception.new is #<Exception: Exception>\n"
+    end
+
+    it "inspects values" do
+      x = "flavor:\tvanilla"
+      d = details { assert { x == "flavor:\tchocolate" } }
+      # this means it's a literal slash plus t inside double quotes -- i.e. it shows the escaped (inspected) string
+      assert d == "\n" + '    x is "flavor:\tvanilla"' + "\n"
+    end
+
+    it "indents unescaped newlines inside the inspected value" do
+      weirdo = Object.new
+
+      def weirdo.inspect
+        "first\nsecond\nthird"
+      end
+
+      x = weirdo
+      d = details { assert { x == "foo" } }
+      assert d == "\n    x is first\n      second\n      third\n"
+    end
+
+  end
+end