google-geo 1.0 → 2.0

data/vendor/mocha-0.4.0/test/mocha/object_test.rb

@@ -0,0 +1,165 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mock'
+require 'method_definer'
+
+require 'mocha/object'
+
+class ObjectTest < Test::Unit::TestCase
+  
+  include Mocha
+    
+  def test_should_build_mocha
+    instance = Object.new
+    mocha = instance.mocha
+    assert_not_nil mocha
+    assert mocha.is_a?(Mock)
+  end
+  
+  def test_should_reuse_existing_mocha
+    instance = Object.new
+    mocha_1 = instance.mocha
+    mocha_2 = instance.mocha
+    assert_equal mocha_1, mocha_2
+  end
+  
+  def test_should_reset_mocha
+    instance = Object.new
+    assert_nil instance.reset_mocha
+  end
+  
+  def test_should_stub_instance_method
+    instance = Object.new
+    $stubba = Mock.new
+    $stubba.expects(:stub).with(Mocha::InstanceMethod.new(instance, :method1))
+    instance.expects(:method1)
+    $stubba.verify
+  end 
+  
+  def test_should_build_and_store_expectation
+    instance = Object.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    expectation = instance.expects(:method1)
+    assert_equal [expectation], instance.mocha.expectations
+  end
+  
+  def test_should_verify_expectations
+    instance = Object.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    instance.expects(:method1).with(:value1, :value2)
+    assert_raise(ExpectationError) { instance.verify }
+  end
+  
+  def test_should_pass_backtrace_into_expects
+    instance = Object.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    mocha = Object.new
+    mocha.define_instance_accessor(:expects_parameters)
+    mocha.define_instance_method(:expects) { |*parameters| self.expects_parameters = parameters }
+    backtrace = Object.new
+    instance.define_instance_method(:mocha) { mocha }
+    instance.define_instance_method(:caller) { backtrace }
+    instance.expects(:method1)
+    assert_equal [:method1, backtrace], mocha.expects_parameters
+  end
+      
+  def test_should_pass_backtrace_into_stubs
+    instance = Object.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    mocha = Object.new
+    mocha.define_instance_accessor(:stubs_parameters)
+    mocha.define_instance_method(:stubs) { |*parameters| self.stubs_parameters = parameters }
+    backtrace = Object.new
+    instance.define_instance_method(:mocha) { mocha }
+    instance.define_instance_method(:caller) { backtrace }
+    instance.stubs(:method1)
+    assert_equal [:method1, backtrace], mocha.stubs_parameters
+  end
+      
+  def test_should_build_any_instance_object
+    klass = Class.new
+    any_instance = klass.any_instance
+    assert_not_nil any_instance
+    assert any_instance.is_a?(Class::AnyInstance)
+  end
+  
+  def test_should_return_same_any_instance_object
+    klass = Class.new
+    any_instance_1 = klass.any_instance
+    any_instance_2 = klass.any_instance
+    assert_equal any_instance_1, any_instance_2
+  end
+  
+  def test_should_stub_class_method
+    klass = Class.new
+    $stubba = Mock.new
+    $stubba.expects(:stub).with(Mocha::ClassMethod.new(klass, :method1))
+    klass.expects(:method1)
+    $stubba.verify
+  end 
+  
+  def test_should_build_and_store_class_method_expectation
+    klass = Class.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    expectation = klass.expects(:method1)
+    assert_equal [expectation], klass.mocha.expectations
+  end
+  
+  def test_should_stub_module_method
+    mod = Module.new
+    $stubba = Mock.new
+    $stubba.expects(:stub).with(Mocha::ClassMethod.new(mod, :method1))
+    mod.expects(:method1)
+    $stubba.verify
+  end
+  
+  def test_should_build_and_store_module_method_expectation
+    mod = Module.new
+    $stubba = Mock.new
+    $stubba.stubs(:stub)
+    expectation = mod.expects(:method1)
+    assert_equal [expectation], mod.mocha.expectations
+  end
+  
+  def test_should_use_stubba_instance_method_for_object
+    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
+  end
+    
+  def test_should_use_stubba_class_method_for_module
+    assert_equal Mocha::ClassMethod, Module.new.stubba_method
+  end
+    
+  def test_should_use_stubba_class_method_for_class
+    assert_equal Mocha::ClassMethod, Class.new.stubba_method
+  end
+  
+  def test_should_use_stubba_class_method_for_any_instance
+    assert_equal Mocha::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
+  end
+  
+  def test_should_stub_self_for_object
+    object = Object.new
+    assert_equal object, object.stubba_object
+  end
+      
+  def test_should_stub_self_for_module
+    mod = Module.new
+    assert_equal mod, mod.stubba_object
+  end
+      
+  def test_should_stub_self_for_class
+    klass = Class.new
+    assert_equal klass, klass.stubba_object
+  end
+      
+  def test_should_stub_relevant_class_for_any_instance
+    klass = Class.new
+    any_instance = Class::AnyInstance.new(klass)
+    assert_equal klass, any_instance.stubba_object
+  end
+  
+end

data/vendor/mocha-0.4.0/test/mocha/pretty_parameters_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/pretty_parameters'
+
+class PrettyParametersTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_remove_outer_array_braces
+    params = [1, 2, [3, 4]]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, 2, [3, 4]', parameters.pretty
+  end
+  
+  def test_should_display_numeric_arguments_as_is
+    params = [1, 2, 3]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, 2, 3', parameters.pretty
+  end
+  
+  def test_should_remove_curly_braces_if_hash_is_only_argument
+    params = [{:a => 1, :z => 2}]
+    parameters = PrettyParameters.new(params)
+    assert_match /^:[az] => [12], :[az] => [12]$/, parameters.pretty
+  end
+  
+  def test_should_not_remove_curly_braces_if_hash_is_not_the_only_argument
+    params = [1, {:a => 1}]
+    parameters = PrettyParameters.new(params)
+    assert_equal '1, {:a => 1}', parameters.pretty
+  end
+
+end

data/vendor/mocha-0.4.0/test/mocha/setup_and_teardown_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mock'
+
+require 'mocha/setup_and_teardown'
+
+class SetupAndTeardownTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_instantiate_new_stubba
+    test_case = stubbed_test_case_class.new
+    test_case.setup_stubs
+    
+    assert $stubba
+    assert $stubba.is_a?(Mocha::Central)
+  end
+
+  def test_should_verify_all_expectations
+    test_case = stubbed_test_case_class.new
+    stubba = Mock.new
+    stubba.expects(:verify_all)
+    $stubba = stubba
+    
+    test_case.verify_stubs
+    
+    stubba.verify
+  end
+
+  def test_should_yield_to_block_for_each_assertion
+    test_case = stubbed_test_case_class.new
+    $stubba = Mock.new
+    $stubba.stubs(:verify_all).yields
+    yielded = false
+    
+    test_case.verify_stubs { yielded = true }
+    
+    assert_equal true, yielded
+  end
+
+  def test_should_unstub_all_stubbed_methods
+    test_case = stubbed_test_case_class.new
+    stubba = Mock.new
+    stubba.expects(:unstub_all)
+    $stubba = stubba
+    
+    test_case.teardown_stubs
+    
+    stubba.verify
+  end
+
+  def test_should_set_stubba_to_nil
+    test_case = stubbed_test_case_class.new
+    $stubba = Mock.new
+    $stubba.stubs(:unstub_all)
+
+    test_case.teardown_stubs
+    
+    assert_nil $stubba
+  end
+  
+  def test_should_not_raise_exception_if_no_stubba_central_available
+    test_case = stubbed_test_case_class.new
+    $stubba = nil
+    assert_nothing_raised { test_case.teardown_stubs }
+  end
+  
+  private
+  
+  def stubbed_test_case_class
+    Class.new do
+      include Mocha::SetupAndTeardown
+    end
+  end
+
+end
+

data/vendor/mocha-0.4.0/test/mocha_acceptance_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+require 'mocha'
+
+class MochaAcceptanceTest < Test::Unit::TestCase
+  
+  class Rover
+
+    def initialize(left_track, right_track, steps_per_metre, steps_per_degree)
+      @left_track, @right_track, @steps_per_metre, @steps_per_degree = left_track, right_track, steps_per_metre, steps_per_degree
+    end
+
+    def forward(metres)
+      @left_track.step(metres * @steps_per_metre)
+      @right_track.step(metres * @steps_per_metre)
+      wait
+    end
+
+    def backward(metres)
+      forward(-metres)
+    end
+    
+    def left(degrees)
+      @left_track.step(-degrees * @steps_per_degree)
+      @right_track.step(+degrees * @steps_per_degree)
+      wait
+    end
+    
+    def right(degrees)
+      left(-degrees)
+    end
+    
+    def wait
+      while (@left_track.moving? or @right_track.moving?); end
+    end
+
+  end
+  
+  def test_should_step_both_tracks_forward_ten_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:step).with(10)
+    right_track.expects(:step).with(10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.forward(2)
+  end
+  
+  def test_should_step_both_tracks_backward_ten_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_metre = 5
+    rover = Rover.new(left_track, right_track, steps_per_metre, nil)
+    
+    left_track.expects(:step).with(-10)
+    right_track.expects(:step).with(-10)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.backward(2)
+  end
+  
+  def test_should_step_left_track_forwards_five_steps_and_right_track_backwards_five_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:step).with(+5)
+    right_track.expects(:step).with(-5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.right(90)
+  end
+  
+  def test_should_step_left_track_backwards_five_steps_and_right_track_forwards_five_steps
+    left_track = mock('left_track')
+    right_track = mock('right_track')
+    steps_per_degree = 5.0 / 90.0
+    rover = Rover.new(left_track, right_track, nil, steps_per_degree)
+    
+    left_track.expects(:step).with(-5)
+    right_track.expects(:step).with(+5)
+    
+    left_track.stubs(:moving?).returns(false)
+    right_track.stubs(:moving?).returns(false)
+    
+    rover.left(90)
+  end
+  
+end

data/vendor/mocha-0.4.0/test/mocha_test_result_integration_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+require 'mocha/standalone'
+require 'mocha/test_case_adapter'
+require 'execution_point'
+
+class MochaTestResultIntegrationTest < Test::Unit::TestCase
+  
+  def test_should_include_expectation_verification_in_assertion_count
+    test_result = run_test do
+      object = mock()
+      object.expects(:message)
+      object.message
+    end
+    assert_equal 1, test_result.assertion_count
+  end
+  
+  def test_should_include_assertions_in_assertion_count
+    test_result = run_test do
+      assert true
+    end
+    assert_equal 1, test_result.assertion_count
+  end
+  
+  def test_should_not_include_stubbing_expectation_verification_in_assertion_count
+    test_result = run_test do
+      object = mock()
+      object.stubs(:message)
+      object.message
+    end
+    assert_equal 0, test_result.assertion_count
+  end
+  
+  def test_should_include_expectation_verification_failure_in_failure_count
+    test_result = run_test do
+      object = mock()
+      object.expects(:message)
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_include_unexpected_verification_failure_in_failure_count
+    test_result = run_test do
+      object = mock()
+      object.message
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_include_assertion_failure_in_failure_count
+    test_result = run_test do
+      flunk
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_expects_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      object = mock()
+      execution_point = ExecutionPoint.current; object.expects(:message)
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_unexpected_method_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      object = mock()
+      execution_point = ExecutionPoint.current; object.message 
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_failing_assertion_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      execution_point = ExecutionPoint.current; flunk
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def run_test(test_result = Test::Unit::TestResult.new, &block)
+    test_class = Class.new(Test::Unit::TestCase) do
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
+      define_method(:test_me, &block)
+    end
+    test = test_class.new(:test_me)
+    test.run(test_result) {}
+    test_result
+  end
+  
+end