synthesis 0.1.5 → 0.1.6

data/Rakefile

@@ -7,7 +7,7 @@ require File.dirname(__FILE__) + "/lib/synthesis/task"
 
 load 'synthesis.gemspec'
 
-task :default => :test
+task :default => [:test, "test_project:all"]
 
 desc "Run all tests"
 task :test => %w[test:core test:mocha test:spec]
@@ -43,6 +43,26 @@ Synthesis::Task.new('synthesis:spec') do |t|
   t.pattern = 'test_project/rspec/*_spec.rb'
 end
 
+namespace :test_project do
+  task :all do
+    STDOUT.puts `rake test_project:mocha`
+    STDOUT.puts `rake test_project:rspec`
+    STDOUT.puts `rake test_project:expectations`
+  end
+  
+  Rake::TestTask.new('mocha') do |t|
+    t.pattern = 'test_project/mocha/**/*_test.rb'
+  end
+  
+  Rake::TestTask.new('rspec') do |t|
+    t.pattern = 'test_project/mocha/**/*_test.rb'
+  end
+  
+  Rake::TestTask.new('expectations') do |t|
+    t.pattern = 'test_project/mocha/**/*_test.rb'
+  end
+end
+
 desc 'Generate RDoc'
 Rake::RDocTask.new do |task|
   task.main = 'README'
@@ -64,4 +84,14 @@ Rake::GemPackageTask.new(GEMSPEC) do |t|
 end
 
 desc "Remove rdoc and package artefacts"
-task :clean => %w[clobber_package clobber_rdoc]
+task :clean => %w[clobber_package clobber_rdoc]
+
+task(:lf) {p Dir["lib/**/*rb"] }
+
+task(:check_gemspec) do
+  require 'rubygems/specification'
+  data = File.read('synthesis.gemspec')
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  puts spec
+end

data/lib/synthesis/adapter/expectations.rb

@@ -18,6 +18,7 @@ module Synthesis
       Mocha::Expectation.record_expected_arguments_on(:with)
       Mocha::Expectation.record_expected_return_values_on(:returns)
       Mocha::Expectation.record_expected_return_values_on(:raises)
+      Mocha::Expectation.remove_expectation_on(:never)
     end
     
     def stop_collecting_expectations

data/lib/synthesis/adapter/rspec.rb

@@ -7,11 +7,11 @@ require File.dirname(__FILE__) + "/../../synthesis"
 module Synthesis
   class RSpecAdapter < Adapter
     def run
-      rspec_options.files.clear
+      Synthesis.rspec_runner_options.files.clear
       fail_unless do
-        rspec_options.instance_variable_set(:@formatters, nil)
-        # rspec_options.instance_variable_set(:@format_options, [["profile", STDOUT]])
-        rspec_options.run_examples
+        Synthesis.rspec_runner_options.instance_variable_set(:@formatters, nil)
+        # Synthesis.rspec_runner_options.instance_variable_set(:@format_options, [["profile", STDOUT]])
+        Synthesis.rspec_runner_options.run_examples
       end
     end
     
@@ -30,5 +30,11 @@ module Synthesis
       Spec::Mocks::MessageExpectation.stop_intercepting!
       Spec::Mocks::Methods.stop_recording!
     end
-  end  
+  end
+  
+  def rspec_runner_options
+    Spec::Runner.options rescue rspec_options
+  end
+  
+  module_function :rspec_runner_options
 end

data/lib/synthesis/recordable.rb

@@ -1,7 +1,7 @@
 module Synthesis
   module Recordable
     def recordable_method(meth)
-      if method_defined?(meth)
+      if method_defined?(meth) || private_method_defined?(meth)
         defined_recordable_method(meth)
       else
         magic_recordable_method(meth)

data/lib/synthesis/task.rb

@@ -6,10 +6,10 @@ require File.dirname(__FILE__) + "/../synthesis/logging"
 module Synthesis
   class Task < Rake::TaskLib
     include Logging
-    attr_accessor :verbose, :pattern, :ruby_opts, :adapter, :out, :ignored
+    attr_accessor :verbose, :pattern, :ruby_opts, :adapter, :out, :ignored, :libs
 
     def initialize(name='synthesis:test')
-      @name, @ignored = name, []
+      @name, @ignored, @libs = name, [], []
       yield self if block_given?
       @pattern ||= 'test/**/*_test.rb'
       @ruby_opts ||= []
@@ -32,7 +32,7 @@ module Synthesis
       desc "Run Synthesis tests"
       task @name do
         RakeFileUtils.verbose(@verbose) do
-          @ruby_opts.unshift("-w") if @warning
+          load_paths
           require File.dirname(__FILE__) + "/../synthesis"
           require File.dirname(__FILE__) + "/../synthesis/runner"
           Synthesis::Logging.const_set(:OUT, @out) if @out
@@ -42,5 +42,10 @@ module Synthesis
       end
       self
     end
+
+    private 
+    def load_paths
+      @libs.each { |path| $:.unshift(File.join(Dir.pwd, path)) }
+    end
   end
 end

data/synthesis.gemspec

@@ -0,0 +1,41 @@
+GEMSPEC =Gem::Specification.new do |s|
+  s.name = 'synthesis'
+  s.version = '0.1.6'
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "synthesis"
+  s.summary, s.description = 'A tool for Synthesized Testing'
+  s.authors = 'Stuart Caborn, George Malamidis'
+  s.email = 'george@nutrun.com'
+  s.homepage = 'http://synthesis.rubyforge.org'
+  s.has_rdoc = true
+  s.rdoc_options += ['--quiet', '--title', 'Synthesis', '--main', 'README', '--inline-source']
+  s.extra_rdoc_files = ['README', 'COPYING']
+  s.files = [
+    "COPYING",
+    "Rakefile",
+    "README",
+    "synthesis.gemspec",
+    "lib/synthesis/adapter/expectations.rb",
+    "lib/synthesis/adapter/mocha.rb",
+    "lib/synthesis/adapter/rspec.rb",
+    "lib/synthesis/adapter.rb",
+    "lib/synthesis/class.rb",
+    "lib/synthesis/expectation.rb",
+    "lib/synthesis/expectation_interceptor.rb",
+    "lib/synthesis/expectation_matcher.rb",
+    "lib/synthesis/expectation_record.rb",
+    "lib/synthesis/expectation_record_enabled.rb",
+    "lib/synthesis/logging.rb",
+    "lib/synthesis/method_invocation_watcher.rb",
+    "lib/synthesis/module.rb",
+    "lib/synthesis/object.rb",
+    "lib/synthesis/recordable.rb",
+    "lib/synthesis/reporter.rb",
+    "lib/synthesis/runner.rb",
+    "lib/synthesis/task.rb",
+    "lib/synthesis/util/mock_instance/mocha.rb",
+    "lib/synthesis/util/mock_instance/rspec.rb",
+    "lib/synthesis/util/mock_instance.rb",
+    "lib/synthesis.rb"
+  ]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: synthesis
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - Stuart Caborn, George Malamidis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-03 00:00:00 +01:00
+date: 2008-10-17 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,10 @@ extra_rdoc_files:
 - README
 - COPYING
 files: 
+- COPYING
+- Rakefile
+- README
+- synthesis.gemspec
 - lib/synthesis/adapter/expectations.rb
 - lib/synthesis/adapter/mocha.rb
 - lib/synthesis/adapter/rspec.rb
@@ -45,34 +49,6 @@ files:
 - lib/synthesis/util/mock_instance/rspec.rb
 - lib/synthesis/util/mock_instance.rb
 - lib/synthesis.rb
-- test/synthesis/adapter/mocha/expectation_record_test.rb
-- test/synthesis/adapter/mocha/helper.rb
-- test/synthesis/adapter/mocha/mocha_expectation_test.rb
-- test/synthesis/adapter/mocha/mocha_test.rb
-- test/synthesis/adapter/mocha/object_test.rb
-- test/synthesis/adapter/rspec/expectation_record_test.rb
-- test/synthesis/adapter/rspec/helper.rb
-- test/synthesis/adapter/rspec/message_expectation_test.rb
-- test/synthesis/adapter/rspec/methods_test.rb
-- test/synthesis/class_test.rb
-- test/synthesis/expectation_matcher_test.rb
-- test/synthesis/expectation_record_test.rb
-- test/synthesis/expectation_test.rb
-- test/synthesis/helper.rb
-- test/synthesis/method_invocation_watcher_test.rb
-- test/synthesis/module_test.rb
-- test/synthesis/object_test.rb
-- test/synthesis/recordable_test.rb
-- test_project/expectations/test/data_brander_test.rb
-- test_project/expectations/test/storage_test.rb
-- test_project/mocha/test/data_brander_test.rb
-- test_project/mocha/test/storage_test.rb
-- test_project/rspec/data_brander_spec.rb
-- test_project/rspec/storage_spec.rb
-- test_project/test_project.rb
-- COPYING
-- README
-- Rakefile
 has_rdoc: true
 homepage: http://synthesis.rubyforge.org
 post_install_message: 

data/test/synthesis/adapter/mocha/expectation_record_test.rb

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ExpectationRecordTest < Test::Unit::TestCase
-    def teardown
-      ExpectationRecord.send(:reset!)
-    end
-
-    def test_does_not_add_any_instance_expectation
-      any = Class::AnyInstance.new(Object)
-      ExpectationRecord.add_expectation(any, :foo, :track)
-      assert_equal(0, ExpectationRecord.expectations.size)
-    end  
-  end
-end

data/test/synthesis/adapter/mocha/helper.rb

@@ -1,3 +0,0 @@
-%w(test/unit rubygems mocha).each { |l| require l }
-require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
-Synthesis::MochaAdapter.new(nil).collect_expectations

data/test/synthesis/adapter/mocha/mocha_expectation_test.rb

@@ -1,26 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class MochaExpectationTest < Test::Unit::TestCase
-  def setup
-    @mocha_expectation = Mocha::Expectation.new(:mock, :blah)
-    @synthesis_expectation = Synthesis::Expectation.new(Hash, :method, :track, [], [1])
-  end
-  
-  def test_holds_synthesis_expectation
-    @mocha_expectation.synthesis_expectation = @synthesis_expectation
-    assert_equal(@synthesis_expectation, @mocha_expectation.synthesis_expectation)
-  end
-  
-  def test_with_passes_expected_params_to_synthesis_expectation
-    @mocha_expectation.synthesis_expectation = @synthesis_expectation
-    @mocha_expectation.with(1, 2)
-    assert_equal([1, 2], @mocha_expectation.synthesis_expectation.args)
-  end
-  
-  def test_passes_return_values_to_synthesis_expectation
-    @mocha_expectation.synthesis_expectation = @synthesis_expectation
-    @mocha_expectation.returns(:rock)
-    return_values = @synthesis_expectation.instance_variable_get(:@return_values)
-    assert_equal([1, :rock], return_values)
-  end
-end

data/test/synthesis/adapter/mocha/mocha_test.rb

@@ -1,9 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class MochaTest < Test::Unit::TestCase
-    def test_sets_mock_object_to_class_any_instance
-      assert_equal(Class::AnyInstance, Synthesis::MOCK_OBJECT)
-    end
-  end
-end

data/test/synthesis/adapter/mocha/object_test.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ObjectTest < Test::Unit::TestCase
-    def test_records_singleton_method_expectation
-      ExpectationRecord.expects(:add_expectation).with(Hash, :foo, kind_of(String))
-      Hash.expects(:foo)
-      Hash.foo
-    end
-
-    def test_records_instance_method_expectation
-      hash = Hash.new
-      ExpectationRecord.expects(:add_expectation).with(hash, :foo, kind_of(String))
-      hash.expects(:foo)
-      hash.foo
-    end  
-  end
-end

data/test/synthesis/adapter/rspec/expectation_record_test.rb

@@ -1,15 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ExpectationRecordTest < Test::Unit::TestCase
-    def teardown
-      ExpectationRecord.send(:reset!)
-    end
-
-    def test_does_not_add_any_instance_expectation
-      mock = Spec::Mocks::Mock.new(Numeric)
-      ExpectationRecord.add_expectation(mock, :foo, :track)
-      assert_equal(0, ExpectationRecord.expectations.size)
-    end  
-  end
-end

data/test/synthesis/adapter/rspec/helper.rb

@@ -1,3 +0,0 @@
-require "test/unit"
-require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/rspec"
-Synthesis::RSpecAdapter.new(nil).collect_expectations

data/test/synthesis/adapter/rspec/message_expectation_test.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class MessageExpectationTest < Test::Unit::TestCase
-  def setup
-    error_generator = Class.new {def opts=(param)end}.new
-    @spec_expectation = Spec::Mocks::MessageExpectation.new(error_generator, :n, :n, :n, :n)
-  end
-  
-  def test_holds_synthesis_expectation
-    @spec_expectation.synthesis_expectation = 1
-    assert_equal 1, @spec_expectation.synthesis_expectation
-  end
-  
-  def test_with_passes_expected_params_to_synthesis_expectation
-    @spec_expectation.synthesis_expectation = Synthesis::Expectation.new(Hash, :foo, :track)
-    @spec_expectation.with 1, 2
-    assert_equal([1, 2], @spec_expectation.synthesis_expectation.args)
-  end
-end

data/test/synthesis/adapter/rspec/methods_test.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class MethodsTest < Test::Unit::TestCase
-    def teardown
-      ExpectationRecord.send(:reset!)
-    end
-    
-    def test_records_singleton_method_expectation
-      ExpectationRecord.should_receive(:add_expectation).with(Hash, :foo, an_instance_of(String))
-      Hash.should_receive(:foo)
-      Hash.foo
-    end
-
-    def test_records_instance_method_expectation
-      hash = Hash.new
-      ExpectationRecord.should_receive(:add_expectation).with(hash, :foo, an_instance_of(String))
-      hash.should_receive(:foo)
-      hash.foo
-    end  
-  end
-end

data/test/synthesis/class_test.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class ClassTest < Test::Unit::TestCase
-  def test_has_singleton_expectation
-    assert_instance_of(Synthesis::Expectation::Singleton, Hash.expectation(:foo, :track))
-  end
-end

data/test/synthesis/expectation_matcher_test.rb

@@ -1,54 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ExpectationMatcherTest < Test::Unit::TestCase
-    def test_match
-      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
-      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
-      assert(ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_no_match_based_on_expectation_type
-      exp1 = Expectation.new(Array, :foo, :track, [Array, Hash], [Array, Hash])
-      exp2 = Expectation.new(Array.new, :foo, :track, [Array, Hash], [Array, Hash])
-      assert(!ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_no_match_based_on_receiver_type
-      exp1 = Expectation.new(Array.new, :foo, :track, [Array, Hash], [Array, Hash])
-      exp2 = Expectation.new(Hash.new, :foo, :track, [Array, Hash], [Array, Hash])
-      assert(!ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_no_match_based_on_method_name
-      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
-      exp2 = Expectation.new(Object.new, :bar, :track, [Array, Hash], [Array, Hash])
-      assert(!ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_no_match_based_on_arg_types
-      exp1 = Expectation.new(Object.new, :foo, :track, [1, "a"], [Array, Hash])
-      exp2 = Expectation.new(Object.new, :foo, :track, [1, 2], [Array, Hash])
-      assert(!ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_no_match_based_on_return_value_types
-      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
-      exp1.add_return_values(:sym)
-      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], ["string"])
-      assert(!ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_match_based_on_return_value_types
-      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [[1], {:a => :b}])
-      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [[4], {:a => 9}])
-      assert(ExpectationMatcher.new(exp1, exp2).match?)
-    end
-    
-    def test_ignores_return_value_types_unless_return_values_defined
-      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
-      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
-      assert(ExpectationMatcher.new(exp1, exp2).match?)
-    end
-  end  
-end

data/test/synthesis/expectation_record_test.rb

@@ -1,89 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ExpectationRecordTest < Test::Unit::TestCase
-    def teardown
-      ExpectationRecord.send(:reset!)
-    end
-
-    def test_adds_expectation
-      ExpectationRecord.add_expectation(Object.new, :to_s, :track)
-      assert_equal(1, ExpectationRecord.expectations.size)
-    end
-
-    def test_watches_expectation_invocations
-      c = Class.new { def foo; end }
-      ExpectationRecord.add_expectation(c.new, :foo, :track)
-      ExpectationRecord.record_invocations
-      a = c.new
-      MethodInvocationWatcher.expects(:invoked).with(a, :foo, [], [nil])
-      a.foo
-    end
-
-    def test_finds_expectation
-      c = Class.new { def foo; end }
-      expected = ExpectationRecord.add_expectation(c.new, :foo, :track)
-      expected.add_return_values(20)
-      ExpectationRecord.record_invocations
-      matcher = Expectation.new(c.new, :foo, :track, [], [20])
-      actual = ExpectationRecord[matcher]
-      assert_equal(expected, actual)
-    end
-
-    def test_returns_nil_expectation_on_no_expectation_found
-      ExpectationRecord.add_expectation(Object.new, :foo, :track)
-      matcher = Expectation.new(Object.new, :bar, :track)
-      actual_instance = ExpectationRecord[matcher]
-      assert_kind_of(Expectation::NilExpectation, actual_instance)
-    end
-
-    def test_does_not_add_expectation_for_ignored_class
-      ExpectationRecord.ignore(Hash)
-      ExpectationRecord.add_expectation(Hash, :foo, :track)
-      assert(ExpectationRecord.expectations.empty?)
-    end
-    
-    def test_does_not_add_expectation_for_ignored_object
-      ExpectationRecord.ignore(Hash)
-      ExpectationRecord.add_expectation(Hash.new, :foo, :track)
-      assert(ExpectationRecord.expectations.empty?)
-    end
-    
-    def test_does_not_add_expectation_for_ignored_module
-      ExpectationRecord.ignore(Enumerable)
-      ExpectationRecord.add_expectation(Enumerable, :foo, :track)
-      assert(ExpectationRecord.expectations.empty?)
-    end
-    
-    def test_returns_added_expectation_on_add
-      expected = Expectation.new(Hash, :foo, :track, [], [:return_val])
-      actual = ExpectationRecord.add_expectation(Hash, :foo, :track)
-      actual.add_return_values(:return_val)
-      assert_equal(expected, actual)
-    end
-    
-    def test_uniqs_expectations_before_recording_invocations
-      c = Class.new { def foo; end }
-      ExpectationRecord.add_expectation(c, :foo, :track)
-      ExpectationRecord.add_expectation(c, :foo, :track)
-      assert_equal(2, ExpectationRecord.expectations.size)
-      ExpectationRecord.record_invocations
-      assert_equal(1, ExpectationRecord.expectations.size)
-    end
-    
-    def test_flattens_expectations_before_recording_invocations
-      c = Class.new { def foo; end }
-      expectation = ExpectationRecord.add_expectation(c, :foo, :track)
-      expectation.add_return_values(1, "str", "sym")
-      ExpectationRecord.record_invocations
-      ExpectationRecord.expectations.each { |val| assert(!val.is_a?(Array)) }
-    end
-    
-    def test_removes_expectation
-      c = Class.new { def foo; end }
-      expectation = ExpectationRecord.add_expectation(c, :foo, :track)
-      ExpectationRecord.remove(expectation)
-      assert_equal(0, ExpectationRecord.expectations.size)
-    end
-  end
-end

data/test/synthesis/expectation_test.rb

@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class ExpectationTest < Test::Unit::TestCase
-    def test_creates_singleton_method_expectation_given_class
-      expectation = Expectation.new(Class.new, :foo, :track)
-      assert_kind_of(Expectation::Singleton, expectation)
-    end
-
-    def test_creates_instance_method_expectation_given_instance
-      expectation = Expectation.new(Class.new.new, :foo, :track)
-      assert_kind_of(Expectation::Instance, expectation)
-    end
-
-    def test_creates_singleton_method_expectation_given_module
-      expectation = Expectation.new(Module.new, :foo, :track)
-      assert_kind_of(Expectation::Singleton, expectation)
-    end
-
-    def test_records_instance_receiver_method_invocations
-      receiver = Class.new { def foo;end }
-      expectation = Expectation.new(receiver.new, :foo, :track)
-      expectation.record_invocations
-      assert_respond_to(receiver.new, :__recordable__foo)
-    end
-
-    def test_records_singleton_receiver_method_invocations
-      receiver = Class.new { def self.foo;end }
-      expectation = Expectation.new(receiver, :foo, :track, [], [:return])
-      expectation.record_invocations
-      assert_respond_to(receiver, :__recordable__foo)
-    end
-    
-    def test_make_sure_equality_works_with_uniq
-      expectations = [
-        Expectation.new(String, :new, [], [:arg1, :arg2], [:return]), 
-        Expectation.new(String, :new, [], [:arg1, :arg2], [:return])
-      ]
-      assert_equal(1, expectations.uniq.size)
-    end
-    
-    def test_singleton_receiver_class
-      assert_equal(String, Expectation.new(String, :new, :track, [], []).receiver_class)
-    end
-    
-    def test_instance_receiver_class
-      assert_equal(String, Expectation.new(String.new, :new, :track, [], []).receiver_class)
-    end
-    
-    def test_arg_types
-      expectation = Expectation.new(String.new, :new, :track, [:sym, "str"], [])
-      assert_equal([Symbol, String], expectation.arg_types)
-    end
-        
-    def test_return_value_type
-      expectation = Expectation.new(String, :new, :track)
-      expectation.add_return_values(:sym)
-      assert_equal(Symbol, expectation.return_value_type)
-    end
-    
-    def test_true_class_return_value_type
-      expectation = Expectation.new(String, :new, :track)
-      expectation.add_return_values(true)
-      assert_equal(TrueClass, expectation.return_value_type)
-    end
-    
-    def test_false_class_return_value_type
-      expectation = Expectation.new(String, :new, :track)
-      expectation.add_return_values(false)
-      assert_equal(FalseClass, expectation.return_value_type)
-    end
-    
-    def test_returns_nil_return_value_type_when_no_return_values
-      expectation = Expectation.new(String, :new, :track)
-      assert_nil(expectation.return_value_type)
-    end
-    
-    def test_adds_return_value
-      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
-      expectation.add_return_values("str")
-      actual = expectation.instance_variable_get(:@return_values)
-      assert_equal([:sym, "str"], actual)
-    end
-    
-    def test_return_values_defined_when_return_values_added
-      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
-      expectation.add_return_values("str")
-      assert(expectation.return_values_defined?)
-    end
-    
-    def test_return_values_not_defined_when_no_return_values_added
-      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
-      assert(!expectation.return_values_defined?)
-    end
-    
-    def test_explodes_to_new_expectations_for_each_return_value
-      expectation = Expectation.new(String, :new, :track, [])
-      expectation.add_return_values(:sym, "str")
-      expected = [
-        Expectation.new(String, :new, :track, [], [:sym]),
-        Expectation.new(String, :new, :track, [], ["str"])
-      ]
-      assert_equal(expected, expectation.explode)
-    end
-    
-    def test_returns_self_when_only_one_return_type_on_explode
-      expectation = Expectation.new(String, :new, :track, [])
-      expectation.add_return_values("rock")
-      assert_equal(expectation, expectation.explode)
-    end
-  end
-end

data/test/synthesis/helper.rb

@@ -1,3 +0,0 @@
-%w(test/unit rubygems mocha).each { |l| require l }
-require File.dirname(__FILE__) + "/../../lib/synthesis"
-MOCK_OBJECT = Class.new {}

data/test/synthesis/method_invocation_watcher_test.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class MethodInvocationWatcherTest < Test::Unit::TestCase
-    def teardown
-      ExpectationRecord.send(:reset!)
-    end
-
-    def test_marks_expectation_invoked
-      c = Class.new { def foo; end }
-      ExpectationRecord.add_expectation(c, :to_s, :track, []).add_return_values(1)
-      ExpectationRecord.record_invocations
-      MethodInvocationWatcher.invoked(c, :to_s, [], [1])
-      expectation = ExpectationRecord.expectations.to_a.first
-      assert(expectation.invoked?)
-    end
-  end
-end

data/test/synthesis/module_test.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class ModuleTest < Test::Unit::TestCase
-  def test_has_singleton_expectation
-    assert_instance_of(Synthesis::Expectation::Singleton, Module.new.expectation(:foo, :track))
-  end
-end

data/test/synthesis/object_test.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-class ObjectTest < Test::Unit::TestCase
-  def test_has_instance_expectation
-    assert_instance_of(Synthesis::Expectation::Instance, Object.new.expectation(:foo, :track))
-  end
-end

data/test/synthesis/recordable_test.rb

@@ -1,116 +0,0 @@
-require File.dirname(__FILE__) + "/helper"
-
-module Synthesis
-  class RecordableTest < Test::Unit::TestCase
-    def test_redefines_method
-      foo = Class.new { def a; end }
-      foo.extend(Recordable)
-      foo.recordable_method(:a)
-      assert_respond_to(foo.new, :__recordable__a)
-    end
-
-    def test_records_method_invocation
-      foo = Class.new { def b; end }
-      foo.extend(Recordable)
-      foo.recordable_method(:b)
-      bar = foo.new
-      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [], [nil])
-      bar.b
-    end
-    
-    def test_does_not_redefine_already_redefined_method
-      foo = Class.new { def b; end }
-      foo.extend(Recordable)
-      foo.stubs(:method_defined?).returns(true)
-      foo.expects(:alias_method).never
-      foo.recordable_method(:b)
-    end
-    
-    def test_defines_non_existent_method
-      foo = Class.new
-      foo.extend(Recordable)
-      foo.recordable_method(:bar)
-      assert_respond_to(foo.new, :bar)
-    end
-    
-    def test_defines_non_existent_method_recordable_placeholder_method
-      foo = Class.new
-      foo.extend(Recordable)
-      foo.recordable_method(:bar)
-      assert_respond_to(foo.new, :__recordable__bar)
-    end
-    
-    def test_non_existed_method_placeholder_raises
-      foo = Class.new
-      foo.extend(Recordable)
-      foo.recordable_method(:bar)
-      assert_raise(RuntimeError) { foo.new.__recordable__bar }
-    end
-    
-    def test_does_not_redefine_already_defined_magic_method
-      foo = Class.new
-      foo.extend(Recordable)
-      foo.recordable_method(:b)
-      foo.expects(:alias_method).never
-    end
-    
-    def test_records_magic_method_invocation
-      foo = Class.new {def method_missing(meth, *args) :magic! end}
-      foo.extend(Recordable)
-      foo.recordable_method(:b)
-      bar = foo.new
-      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [], [:magic!])
-      bar.b
-    end
-    
-    def test_records_raised_exception
-      begin
-        foo = Class.new {def bar() raise end}
-        foo.extend(Recordable)
-        foo.recordable_method(:bar)
-        inst = foo.new
-        matcher = Expectation.new(inst, :bar, nil, [])
-        matcher.add_return_values(RuntimeError.new)
-        not_found = Expectation::NilExpectation.new
-        ExpectationRecord.expects(:[]).with(matcher).returns(not_found)
-        inst.bar
-      rescue => e
-        raise e unless e.is_a?(RuntimeError)
-      end
-    end
-    
-    def test_reraises_recorded_exception
-      assert_raise(RuntimeError) do
-        foo = Class.new {def bar() raise end}
-        foo.extend(Recordable)
-        foo.recordable_method(:bar)
-        foo.new.bar
-      end
-    end
-    
-    def test_records_raised_exception_for_magic_method
-      begin
-        foo = Class.new {def method_missing(m, *a) raise end}
-        foo.extend(Recordable)
-        foo.recordable_method(:bar)
-        inst = foo.new
-        matcher = Expectation.new(inst, :bar, nil, [])
-        matcher.add_return_values(RuntimeError.new)
-        not_found = Expectation::NilExpectation.new
-        ExpectationRecord.expects(:[]).with(matcher).returns(not_found)
-        inst.bar
-      rescue => e
-        raise e unless e.is_a?(RuntimeError)
-      end
-    end
-    
-    def test_reraises_recorded_exception_for_magic_method
-      assert_raise(RuntimeError) do
-        foo = Class.new {def method_missing(m, *a) raise end}
-        foo.extend(Recordable)
-        foo.recordable_method(:bar)
-        foo.new.bar
-      end
-    end
-  end
-end

data/test_project/expectations/test/data_brander_test.rb

@@ -1,18 +0,0 @@
-require "rubygems"
-require "expectations"
-require File.dirname(__FILE__) + "/../../test_project"
-
-Expectations do
-  expect Storage.new('whatever').to.receive(:save).with('METAL - rock') do |storage|
-    DataBrander.new(storage).save_branded 'rock'
-  end
-  
-  expect Storage.new("").to.receive(:ouch!).raises(Problem.new) do |storage|
-    begin
-      DataBrander.new(storage).dont_do_this
-    rescue Problem
-      return true
-    end
-    fail
-  end  
-end

data/test_project/expectations/test/storage_test.rb

@@ -1,21 +0,0 @@
-require "rubygems"
-require "expectations"
-require File.dirname(__FILE__) + "/../../test_project"
-
-Expectations do
-  expect "rock" do
-    begin
-      Storage.new('test.txt').save('rock')
-      File.read 'test.txt'
-    ensure
-      FileUtils.rm_f 'test.txt'
-    end
-  end
-  
-  expect Problem do
-    Storage.new("").ouch!
-  end
-  
-  # expect(Storage.new("").to.receive(:never_call_me).never) {}
-  
-end

data/test_project/mocha/test/data_brander_test.rb

@@ -1,36 +0,0 @@
-%w(test/unit rubygems mocha).each { |l| require l }
-require File.dirname(__FILE__) + "/../../test_project"
-
-class DataBranderTest < Test::Unit::TestCase
-  def test_saves_branded_to_storage
-    storage = Storage.new 'whatever'
-    storage.expects(:save).with('METAL - rock')
-    DataBrander.new(storage).save_branded('rock')
-  end
-  
-  def test_ignores_total_ducks
-    m = mock
-    m.expects(:foo)
-    m.foo
-  end
-  
-  def test_delegates_problem
-    storage = Storage.new("")
-    storage.expects(:ouch!).raises(Problem.new)
-    assert_raise(Problem) { DataBrander.new(storage).dont_do_this }
-  end
-  
-  def test_is_ok
-    storage = Storage.new("")
-    storage.expects(:ok_or_problem).with(:ok).returns(:ok)
-    DataBrander.new(storage).ok
-  end
-  
-  def test_does_not_rescue_problem_on_not_ok
-    assert_raise(Problem) do
-      storage = Storage.new("")
-      storage.expects(:ok_or_problem).with(:not_ok).raises(Problem.new)
-      DataBrander.new(storage).not_ok
-    end
-  end
-end

data/test_project/mocha/test/storage_test.rb

@@ -1,31 +0,0 @@
-require "test/unit"
-require "fileutils"
-require File.dirname(__FILE__) + "/../../test_project"
-require "rubygems"
-require "mocha"
-
-class StorageTest < Test::Unit::TestCase
-  def test_saves_to_file
-    Storage.new('test.txt').save('rock')
-    assert_equal 'rock', File.read('test.txt')
-  ensure
-    FileUtils.rm_f('test.txt')
-  end
-  
-  def test_ouch_raises_problem
-    assert_raise(Problem) { Storage.new("").ouch! }
-  end
-  
-  def test_ok_or_problem_returns_ok_when_given_ok
-    assert_equal(:ok, Storage.new("").ok_or_problem(:ok))
-  end
-  
-  def test_ok_raises_problem_when_not_given_ok
-    assert_raise(Problem) { Storage.new("").ok_or_problem(:not_ok) }
-  end
-  
-  def test_never_called
-    storage = Storage.new("")
-    storage.expects(:never_call_me).never
-  end
-end

data/test_project/rspec/data_brander_spec.rb

@@ -1,36 +0,0 @@
-%w(rubygems spec fileutils).each { |l| require l }
-require File.dirname(__FILE__) + "/../test_project"
-
-describe DataBrander do
-  it "should save branded to pstore" do
-    pstore = Storage.new 'whatever'
-    pstore.should_receive(:save).with('METAL - rock')
-    DataBrander.new(pstore).save_branded 'rock'
-  end
-  
-  it "should ignore total ducks" do
-    m = mock(Storage)
-    m.should_receive(:foo)
-    m.foo
-  end
-  
-  it "should delegate problem" do
-    storage = Storage.new("")
-    storage.should_receive(:ouch!).and_raise(Problem.new)
-    proc {DataBrander.new(storage).dont_do_this}.should raise_error(Problem)
-  end
-  
-  it "should return :ok when given :ok" do
-    storage = Storage.new("")
-    storage.should_receive(:ok_or_problem).with(:ok).and_return(:ok)
-    DataBrander.new(storage).ok
-  end
-  
-  it "should not rescue problem on not ok" do
-    proc do
-      storage = Storage.new("")
-      storage.should_receive(:ok_or_problem).with(:not_ok).and_raise(Problem.new)
-      DataBrander.new(storage).not_ok
-    end.should raise_error(Problem)
-  end
-end

data/test_project/rspec/storage_spec.rb

@@ -1,30 +0,0 @@
-%w(rubygems spec fileutils).each { |l| require l }
-require File.dirname(__FILE__) + "/../test_project"
-
-describe Storage do
-  it "should save to file" do
-    begin
-      Storage.new('test.txt').save('rock')
-      File.read('test.txt').should == 'rock'
-    ensure
-      FileUtils.rm_f('test.txt')
-    end
-  end
-  
-  it "should raise problem on ouch!" do
-    proc { Storage.new("").ouch! }.should raise_error(Problem)
-  end
-  
-  it "should return :ok when given :ok" do
-    Storage.new("").ok_or_problem(:ok).should == :ok
-  end
-  
-  it "should raise problem when not give :ok" do
-    proc { Storage.new("").ok_or_problem(:not_ok) }.should raise_error(Problem)
-  end
-  
-  it "should never call" do
-    storage = Storage.new("")
-    storage.should_receive(:never_call_me).never
-  end
-end

data/test_project/test_project.rb

@@ -1,47 +0,0 @@
-class DataBrander
-  BRAND = "METAL"
-  
-  def initialize(storage)
-    @storage = storage
-  end
-  
-  def save_branded(data)
-    @storage.save "#{BRAND} - #{data}"
-  end
-  
-  def dont_do_this
-    @storage.ouch!
-  end
-  
-  def ok
-    @storage.ok_or_problem(:ok)
-  end
-  
-  def not_ok
-    @storage.ok_or_problem(:not_ok)
-  end
-end
-
-class Storage
-  def initialize(filename)
-    @filename = filename
-  end
-  
-  def save(val)
-    File.open(@filename, 'w') {|f| f << val}
-  end
-  
-  def ouch!
-    raise Problem
-  end
-  
-  def ok_or_problem(ok)
-    ok == :ok ? ok : raise(Problem)
-  end
-  
-  def never_call_me
-    :whatever
-  end
-end
-
-class Problem < Exception;end