java_testing_guff 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-01-29
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Mike Hogan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,27 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/java_testing_guff.rb
+lib/java_testing_guff-0.0.1.jar
+lib/java_testing_guff/guff_extensions.rb
+lib/java_testing_guff/qdox_extensions.rb
+lib/java_testing_guff/version.rb
+log/debug.log
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_helper.rb
+test/test_java_testing_guff.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.rhtml

data/README.txt

@@ -0,0 +1 @@
+README

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'java_testing_guff/version'
+
+AUTHOR = 'Mike Hogan'  # can also be an array of Authors
+EMAIL = "me@mikehogan.net"
+DESCRIPTION = "Generates java source code that provides fluent interfaces to configure mock objects in particular states, or real objects in particular states.  Intent is to make writing tests easier.  Requires JRuby and QDox. "
+GEM_NAME = 'java_testing_guff' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'jbuilder-guff' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "m081072"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = JavaTestingGuff::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'java_testing_guff documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps = [ ['guff','>= 0.0.3'] ]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'
+
+

data/config/requirements.rb

@@ -0,0 +1,18 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))
+
+require 'java_testing_guff'
+

data/lib/java_testing_guff.rb

@@ -0,0 +1,169 @@
+$:.unshift File.dirname(__FILE__)
+require 'java_testing_guff/qdox_extensions'
+require 'java_testing_guff/guff_extensions'
+
+module JavaTestingGuff
+    class GuffGenerator
+        def initialize(javadocBuilder)
+            @javadocBuilder = javadocBuilder
+        end
+
+        def save_in(path)
+            @save_path=path
+            self
+        end
+
+        def use_package(p)
+            @packageName=p
+            self
+        end
+
+        def generate_guff_foreach(type_names)
+            type_names.each do |type_name|
+                currentClass=@javadocBuilder.getClassByName(type_name)
+                source = Guff::JavaSource::SourceFile.new.package(@packageName)
+                generate_specific_guff(source, currentClass)
+                source.save_in(@save_path)
+            end
+        end
+
+        def generate_selector_foreach(type_names)
+            source = Guff::JavaSource::SourceFile.new.package(@packageName)
+            source.begin_class(builder_selector_name) {|generated_selector|
+                add_specific_selector_stuff(generated_selector)
+                type_names.each do |type_name|
+                    currentClass=@javadocBuilder.getClassByName(type_name)
+                    generated_selector.add_method(currentClass.selector_method_name).returns(builder_name(currentClass)).body {|body|
+                        body.line("return new #{builder_name(currentClass)}(#{constructor_arguments_for_builder});")
+                    }
+                end
+            }
+            source.save_in(@save_path)
+        end
+
+        def add_specific_selector_stuff(generated_selector)
+
+        end
+
+        def constructor_arguments_for_builder
+            ""
+        end
+    end
+
+    class EasyMockGuffGenerator < GuffGenerator
+        def builder_name(currentClass)
+            "Generated#{currentClass.name}MockBuilder"
+        end
+
+        def builder_selector_name
+            "GeneratedMockBuilderSelector"
+        end
+
+        def generate_specific_guff(source, currentClass)
+            generated_name = builder_name(currentClass)
+            source.import('org.easymock.EasyMock')
+            source.begin_class(generated_name) {|generated_class|
+                generated_class.genericized_using("<T extends #{generated_name}>")
+                generated_class.add_field('mock', currentClass.fullyQualifiedName).final.protected
+
+                generated_class.add_constructor.takes("creator", "org.rubyforge.javatestingguff.MockCreator").body {|body|
+                    body.line("mock = creator.create(#{currentClass.fully_qualified_name}.class);")
+                }
+
+                generated_class.add_method("build").returns(currentClass.fully_qualified_name).body {|body|
+                    body.line('return mock;')
+                }
+
+                generated_class.add_method("apply").returns('T').takes("stuff", "org.rubyforge.javatestingguff.Command").body {|body|
+                    body.line("stuff.execute(this);")
+                    body.line("return (T) this;")
+                }
+                currentClass.with_self_and_supers {|clzz|
+                    clzz.add_easy_mock_methods_to(generated_class)
+                }
+            }
+        end
+    end
+
+    class JMockGuffGenerator < GuffGenerator
+        def builder_name(currentClass)
+            "Generated#{currentClass.name}JMockBuilder"
+        end
+
+        def builder_selector_name
+            "GeneratedJMockBuilderSelector"
+        end
+
+        def constructor_arguments_for_builder
+            "testcase"
+        end
+
+        def add_specific_selector_stuff(generated_selector)
+            generated_selector.add_field("testcase","org.jmock.cglib.MockObjectTestCase").private.final
+            generated_selector.add_constructor.for_field("testcase")
+        end
+
+        def generate_specific_guff(source, currentClass)
+            generated_name = builder_name(currentClass)
+            source.begin_class(generated_name) {|generated_class|
+                generated_class.extends('org.rubyforge.javatestingguff.AbstractJMockObjectBuilder')
+                generated_class.genericized_using("<T extends #{generated_name}>")
+
+
+                generated_class.add_constructor.takes("testCase", "org.jmock.cglib.MockObjectTestCase").body {|body|
+                    body.line("super(testCase,#{currentClass.fully_qualified_name}.class);")
+                }
+
+                generated_class.add_method("build").returns(currentClass.fully_qualified_name).body {|body|
+                    body.line("return (#{currentClass.fully_qualified_name}) mock.proxy();")
+                }
+
+                generated_class.add_method("apply").returns('T').takes("stuff", "org.rubyforge.javatestingguff.Command").body {|body|
+                    body.line("stuff.execute(this);")
+                    body.line("return (T) this;")
+                }
+                currentClass.with_self_and_supers {|clzz|
+                    clzz.add_jmock_methods_to(generated_class)
+                }
+            }
+        end
+    end
+
+
+    class RealBuilderGuffGenerator < GuffGenerator
+        def builder_name(currentClass)
+            "Generated#{currentClass.name}Builder"
+        end
+
+        def builder_selector_name
+            "GeneratedBuilderSelector"
+        end
+
+        def generate_specific_guff(source, currentClass)
+            generated_name = builder_name(currentClass)
+            source.begin_class(generated_name) {|generated_class|
+                generated_class.genericized_using("<T extends #{generated_name}>")
+
+                generated_class.add_method("build").returns(currentClass.fully_qualified_name).body {|body|
+                    variable_name = currentClass.add_simplest_instantiation_line_to(body);
+                    currentClass.with_self_and_supers {|self_or_super|
+                        self_or_super.add_reflective_field_assignments_to(variable_name, body)
+                    }
+                    body.line("return #{variable_name};")
+                }
+
+                currentClass.with_self_and_supers {|self_or_super|
+                    self_or_super.add_field_definitions_to(generated_class)
+                }
+
+                currentClass.with_self_and_supers {|self_or_super|
+                    self_or_super.add_setter_method_definitions_to('with', generated_class)
+                }
+                generated_class.add_method("apply").returns('T').takes("stuff", "org.rubyforge.javatestingguff.Command").body {|body|
+                    body.line("stuff.execute(this);")
+                    body.line("return (T) this;")
+                }
+            }
+        end
+    end
+end

data/lib/java_testing_guff/guff_extensions.rb

@@ -0,0 +1,20 @@
+module VisitMemory
+    def mark_visited(method)
+        methods_visited << method.my_declaration_signature
+    end
+
+    def already_visited?(method)
+        methods_visited.include?(method.my_declaration_signature)
+    end
+    def methods_visited
+        @methods_visited ||= []
+    end
+end
+
+module Guff
+    module JavaSource
+        class Class
+            include VisitMemory
+        end
+    end
+end

data/lib/java_testing_guff/qdox_extensions.rb

@@ -0,0 +1,477 @@
+require 'java'
+require 'rubygems'
+require 'guff'
+require 'active_support'
+require 'forwardable'
+include_class 'com.thoughtworks.qdox.JavaDocBuilder'
+include_class 'com.thoughtworks.qdox.model.JavaMethod'
+include_class 'com.thoughtworks.qdox.model.JavaParameter'
+include_class 'com.thoughtworks.qdox.model.JavaClass'
+include_class 'com.thoughtworks.qdox.model.JavaField'
+include_class 'com.thoughtworks.qdox.model.Type'
+include_class('java.io.File') {|package, name| "J#{name}" }
+
+class JavaField
+    def add_definition_to(generated_class)
+        generated_class.add_field(name, type.fully_qualified_name).protected
+    end
+
+    def add_setter_method_definitions_to(method_name_prefix, generated_class)
+        method_builder = generated_class.add_method("#{method_name_prefix}#{name.camelize}").returns('T').takes(name, type.fully_qualified_name)
+        method_builder.body {|body|
+            body.line("this.#{name} = #{name};")
+            body.line('return (T) this;')
+        }
+    end
+
+    def add_reflective_assignments_to(variable_name, body)
+        body.line("org.rubyforge.javatestingguff.Reflect.setField(#{variable_name},\"#{name}\",#{name});")
+    end
+end
+
+class JavaClass
+    def self.camelize_lower(s)
+        s.first.downcase + s.camelize()[1..-1]
+    end
+
+    def selector_method_name
+        JavaClass::camelize_lower(name)
+    end
+
+    def with_self_and_supers(&proc)
+        proc.call(self)
+        if (interface?)
+            implemented_interfaces.each do |interface|
+                interface.with_self_and_supers &proc
+            end
+        elsif (super_class.fully_qualified_name != "java.lang.Object")
+            super_java_class.with_self_and_supers &proc
+        end
+    end
+
+    def add_easy_mock_methods_to(generated_class)
+        mockable_methods.each do |method|
+            if (!generated_class.already_visited?(method))
+                method.add_easy_mock_builder_to(generated_class)
+                generated_class.mark_visited(method)
+            end
+        end
+    end
+
+    def add_jmock_methods_to(generated_class)
+        mockable_methods.each do |method|
+            if (!generated_class.already_visited?(method))
+                method.add_jmock_builder_to(generated_class)
+                generated_class.mark_visited(method)
+            end
+        end
+    end
+
+    def mockable_methods
+        methods.select {|m|
+            m.public? && !m.static? && !m.constructor?
+        }
+    end
+
+    def add_field_definitions_to(generated_class)
+        instance_fields.each do |field|
+            field.add_definition_to(generated_class)
+        end
+    end
+
+    def instance_fields
+        fields.select {|field|
+            !field.static
+        }
+    end
+
+    def add_setter_method_definitions_to(method_name_prefix, generated_class)
+        instance_fields.each do |field|
+            field.add_setter_method_definitions_to(method_name_prefix, generated_class)
+        end
+    end
+
+    def add_simplest_instantiation_line_to(body)
+        variable_name=JavaClass.camelize_lower(name)
+        body.line("#{fully_qualified_name} #{variable_name} = #{smallest_constructor_call};")
+        variable_name
+    end
+
+    def add_reflective_field_assignments_to(variable_name, body)
+        instance_fields.each do |field|
+            field.add_reflective_assignments_to(variable_name, body)
+        end
+    end
+
+    def constructors
+        methods.select {|method|
+            method.constructor? && method.public?
+        }
+    end
+
+    def smallest_constructor_call
+        sorted_constructors=constructors.sort {|a, b|
+            a.parameters.length <=> b.parameters.length
+        }
+        args=[]
+        if (!sorted_constructors.empty?)
+            smallest_constructor=sorted_constructors.first
+            smallest_constructor.parameters.each do |parameter|
+                args << parameter.any_old_permitted_value
+            end
+        end
+        "new #{fully_qualified_name}(#{args.join(',')})"
+    end
+end
+
+class Type
+    def boolean?
+        one_of?("boolean", 'java.lang.boolean')
+    end
+
+    def one_of?(*possibles)
+        possibles.include?(to_string.downcase)
+    end
+
+    def whole_number?
+        one_of?("long", 'java.lang.long', 'int', 'java.lang.integer')
+    end
+
+    def partial_number?
+        one_of?("float", 'java.lang.float', 'double', 'java.lang.double')
+    end
+
+    def fully_qualified_name
+        result = java_class.fully_qualified_name.gsub("$", ".")
+        if (result.size == 1 && result == result.upcase)
+            result = "Object"
+        end
+        result
+    end
+
+    def fully_qualified_type
+        fully_qualified_name
+    end
+
+    def add_takes_clause_to(method_builder)
+        method_builder.takes(name, fully_qualified_name)
+    end
+
+    def name
+        "result"
+    end
+
+    def add_throws_clause_to(method_builder)
+        method_builder.throws(fully_qualified_name)
+    end
+
+    def any_old_permitted_value
+        if (boolean?)
+            return "true"
+        elsif (whole_number?)
+            return "0"
+        elsif (partial_number?)
+            return "0.0"
+        else
+            return "null"
+        end
+    end
+end
+
+class JavaParameter
+    def add_takes_clause_to(method_builder)
+        method_builder.takes(name, fully_qualified_type)
+    end
+
+    def fully_qualified_type
+        type.fully_qualified_name
+    end
+
+    def any_old_permitted_value
+        type.any_old_permitted_value
+    end
+end
+
+class JavaMethod
+    def my_declaration_signature
+        "#{returns.fully_qualified_name} #{name}(#{parameter_types}) #{throws_clause}"
+    end
+
+    def parameter_types
+        types = parameters.collect do |p|
+            p.type.fully_qualified_name
+        end
+        types.join(",")
+    end
+
+    def throws_clause
+        types=exceptions.collect do |e|
+            e.fully_qualified_name
+        end
+        types.join(",")
+    end
+
+    def add_easy_mock_builder_to(generated_class)
+        EasyMockStubMethodWriter.new(self).add_stub_methods_to(generated_class)
+        add_expectation_methods_to(generated_class) {|body|
+            if (returns_something?)
+                body.line("#{easyMock}.expect(mock.#{name}(#{parameter_list})).andReturn(result);")
+            else
+                body.line("mock.#{name}(#{parameter_list});")
+            end
+        }
+    end
+
+    def add_jmock_builder_to(generated_class)
+        JMockStubMethodWriter.new(self).add_stub_methods_to(generated_class)
+        add_expectation_methods_to(generated_class) {|body|
+            if (returns_something?)
+                body.line("expects(once()).method(\"#{name}\").#{jmock_with_clause}.will(returnValue(result));")
+            else
+                body.line("expects(once()).method(\"#{name}\").#{jmock_with_clause};")
+            end
+        }
+    end
+
+    def jmock_with_clause
+        if (parameters.length == 0)
+            return "withNoArguments()";
+        else
+            clause=[]
+            with_parameters do |p|
+                clause << "eq(#{p.name})"
+            end
+            if (parameters.length > 4)
+                return "with(new org.jmock.core.Constraint[]{#{clause.join(',')}})"
+            else
+                return "with(#{clause.join(',')})"
+            end
+        end
+    end
+
+    def add_expectation_methods_to(generated_class)
+        if (!getter?)
+            method_builder = generated_class.add_method("expecting#{name.camelize}").returns('T')
+            with_parameters_and_return do |p|
+                p.add_takes_clause_to(method_builder)
+            end
+
+            with_exceptions do |e|
+                e.add_throws_clause_to(method_builder)
+            end
+
+            method_builder.body {|body|
+                yield body
+                body.line('return (T) this;')
+            }
+        end
+
+    end
+
+    def with_exceptions
+        exceptions.each do |e|
+            yield e
+        end
+    end
+
+    class StubMethodWriter
+        extend Forwardable
+
+        def_delegator :underlying_method, :setter?
+        def_delegator :underlying_method, :getter?
+        def_delegator :underlying_method, :name
+        def_delegator :underlying_method, :returns
+        def_delegator :underlying_method, :with_parameters_and_return
+        def_delegator :underlying_method, :with_exceptions
+        def_delegator :underlying_method, :returns_something?
+        def_delegator :underlying_method, :parameter_list
+        def_delegator :underlying_method, :jmock_with_clause
+        def_delegator :underlying_method, :easyMock
+
+        def initialize(underlying_method)
+            @underlying_method=underlying_method
+        end
+
+        def underlying_method
+            @underlying_method
+        end
+
+        def add_stub_methods_to(generated_clazz)
+            if (setter?)
+                return
+            end
+
+            if (getter?)
+                add_getter_stub_to(generated_clazz)
+            else
+                method_builder = generated_clazz.add_method("with#{name.camelize}").returns('T')
+                with_parameters_and_return do |p|
+                    p.add_takes_clause_to(method_builder)
+                end
+                with_exceptions do |e|
+                    e.add_throws_clause_to(method_builder)
+                end
+                add_nongetter_stub_to(method_builder)
+            end
+        end
+
+        def add_getter_stub_to(generated_clazz)
+            gotten_field_name = JavaClass.camelize_lower(name.sub(/^get/, "").sub(/^has/, "").sub(/^is/, ""))
+            if (returns.boolean?)
+                generated_method = generated_clazz.add_method("#{JavaClass.camelize_lower(gotten_field_name)}").returns('T')
+                append_throws_clause_if_necessary(generated_method)
+                generated_method.body {|body|
+                    add_boolean_getter_stub_positive_case_to(body)
+                    body.line('return (T) this;')
+                }
+                generated_method = generated_clazz.add_method("not#{gotten_field_name.camelize}").returns('T')
+                append_throws_clause_if_necessary(generated_method)
+                generated_method.body {|body|
+                    add_boolean_getter_stub_negative_case_to(body)
+                    body.line('return (T) this;')
+                }
+            else
+                method_builder = generated_clazz.add_method("with#{gotten_field_name.camelize}").returns('T').takes(gotten_field_name, returns.fully_qualified_name)
+                append_throws_clause_if_necessary(method_builder)
+                method_builder.body {|body|
+                    add_nonboolean_getter_stub_to(body, gotten_field_name)
+                    body.line('return (T) this;')
+                }
+            end
+        end
+
+        def  append_throws_clause_if_necessary(generated_method)
+
+        end
+
+    end
+
+    class EasyMockStubMethodWriter < StubMethodWriter
+        def append_throws_clause_if_necessary(generated_method)
+            with_exceptions do |e|
+                e.add_throws_clause_to(generated_method)
+            end
+        end
+
+        def add_boolean_getter_stub_positive_case_to(body)
+            body.line("#{easyMock}.expect(mock.#{name}()).andStubReturn(true);")
+        end
+
+        def add_boolean_getter_stub_negative_case_to(body)
+            body.line("#{easyMock}.expect(mock.#{name}()).andStubReturn(false);")
+        end
+
+        def add_nonboolean_getter_stub_to(body, gotten_field_name)
+            body.line("#{easyMock}.expect(mock.#{name}()).andStubReturn(#{gotten_field_name});")
+        end
+
+        def add_nongetter_stub_to(method_builder)
+            method_builder.body {|body|
+                if (returns_something?)
+                    body.line("#{easyMock}.expect(mock.#{name}(#{parameter_list})).andStubReturn(result);")
+                else
+                    body.line("mock.#{name}(#{parameter_list});")
+                    body.line("#{easyMock}.expectLastCall().asStub();")
+                end
+                body.line('return (T) this;')
+            }
+
+        end
+    end
+
+    class JMockStubMethodWriter < StubMethodWriter
+        def add_boolean_getter_stub_positive_case_to(body)
+            body.line("stubs().method(\"#{name}\").will(returnValue(true));")
+        end
+
+        def add_boolean_getter_stub_negative_case_to(body)
+            body.line("stubs().method(\"#{name}\").will(returnValue(false));")
+        end
+
+        def add_nonboolean_getter_stub_to(body, gotten_field_name)
+            body.line("stubs().method(\"#{name}\").will(returnValue(#{gotten_field_name}));")
+        end
+
+        def add_nongetter_stub_to(method_builder)
+            method_builder.body {|body|
+                if (returns_something?)
+                    body.line("stubs().method(\"#{name}\").#{jmock_with_clause}.will(returnValue(result));")
+                else
+                    body.line("stubs().method(\"#{name}\").#{jmock_with_clause};")
+                end
+                body.line('return (T) this;')
+            }
+        end
+    end
+
+    def add_easymock_stub_methods_to(generated_clazz)
+        if (setter?)
+            return
+        end
+
+        if (getter?)
+            add_easymock_getter_stub_to(generated_clazz)
+        else
+            method_builder = generated_clazz.add_method("with#{name.camelize}").returns('T')
+            with_parameters_and_return do |p|
+                p.add_takes_clause_to(method_builder)
+            end
+            with_exceptions do |e|
+                e.add_throws_clause_to(method_builder)
+            end
+
+            method_builder.body {|body|
+                if (returns_something?)
+                    body.line("#{easyMock}.expect(mock.#{name}(#{parameter_list})).andStubReturn(result);")
+                else
+                    body.line("mock.#{name}(#{parameter_list});")
+                    body.line("#{easyMock}.expectLastCall().asStub();")
+                end
+                body.line('return (T) this;')
+            }
+        end
+    end
+
+    def parameter_list
+        result=[]
+        with_parameters do |p|
+            result << "#{p.name}"
+        end
+        result.join(',')
+    end
+
+    def with_parameters
+        parameters.each do |p|
+            yield p
+        end
+    end
+
+    def with_parameters_and_return
+        parameters.each do |p|
+            yield p
+        end
+        if (returns_something?)
+            yield returns
+        end
+    end
+
+    def getter?
+        return parameters.length == 0 && returns_something? && (name.starts_with?('get') || name.starts_with?('has') || name.starts_with?('is'))
+    end
+
+    def setter?
+        return parameters.length == 1 && returns_nothing? && name.starts_with?('set')
+    end
+
+    def returns_something?
+        !returns.void?
+    end
+
+    def returns_nothing?
+        returns.void?
+    end
+
+    def easyMock
+        'EasyMock'
+    end
+end