mocha 1.6.0 → 1.7.0

data/test/unit/array_inspect_test.rb

@@ -2,15 +2,13 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/inspect'
 
 class ArrayInspectTest < Mocha::TestCase
-
   def test_should_use_inspect
     array = [1, 2]
     assert_equal array.inspect, array.mocha_inspect
   end
 
   def test_should_use_mocha_inspect_on_each_item
-    array = [1, 2, "chris"]
-    assert_equal %{[1, 2, "chris"]}, array.mocha_inspect
+    array = [1, 2, 'chris']
+    assert_equal %([1, 2, "chris"]), array.mocha_inspect
   end
-
 end

data/test/unit/backtrace_filter_test.rb

@@ -2,18 +2,16 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/backtrace_filter'
 
 class BacktraceFilterTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = "/username/workspace/mocha_wibble/lib/"
-    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
+    mocha_lib = '/username/workspace/mocha_wibble/lib/'
+    backtrace = [mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
     filter = BacktraceFilter.new(mocha_lib)
     assert_equal ['/keep/me'], filter.filtered(backtrace)
   end
 
   def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new("/lib/$"), BacktraceFilter::LIB_DIRECTORY
+    assert_match Regexp.new('/lib/$'), BacktraceFilter::LIB_DIRECTORY
   end
-
 end

data/test/unit/cardinality_test.rb

@@ -2,7 +2,6 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/cardinality'
 
 class CardinalityTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
@@ -52,5 +51,4 @@ class CardinalityTest < Mocha::TestCase
   def test_should_not_need_verifying
     assert_equal false, Cardinality.at_least(0).needs_verifying?
   end
-
 end

data/test/unit/central_test.rb

@@ -5,7 +5,6 @@ require 'mocha/mock'
 require 'method_definer'
 
 class CentralTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_start_with_empty_stubba_methods
@@ -48,48 +47,48 @@ class CentralTest < Mocha::TestCase
 
   def test_should_unstub_specified_method
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(false)
+    method2 = build_mock
+    method2.stubs(:matches?).returns(true)
+    method2.expects(:unstub)
+    stubba.stubba_methods = [method1, method2]
 
-    stubba.unstub(method_2)
+    stubba.unstub(method2)
 
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
+    assert_equal [method1], stubba.stubba_methods
+    assert method2.__verified__?
   end
 
   def test_should_not_unstub_specified_method_if_not_already_stubbed
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.expects(:unstub).never
-    stubba.stubba_methods = [method_1]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(false)
+    method2 = build_mock
+    method2.expects(:unstub).never
+    stubba.stubba_methods = [method1]
 
-    stubba.unstub(method_2)
+    stubba.unstub(method2)
 
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
+    assert_equal [method1], stubba.stubba_methods
+    assert method2.__verified__?
   end
 
   def test_should_unstub_all_methods
     stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(true)
-    method_1.expects(:unstub)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
+    method1 = build_mock
+    method1.stubs(:matches?).returns(true)
+    method1.expects(:unstub)
+    method2 = build_mock
+    method2.stubs(:matches?).returns(true)
+    method2.expects(:unstub)
+    stubba.stubba_methods = [method1, method2]
 
     stubba.unstub_all
 
     assert_equal [], stubba.stubba_methods
-    assert method_1.__verified__?
-    assert method_2.__verified__?
+    assert method1.__verified__?
+    assert method2.__verified__?
   end
 
   private

data/test/unit/change_state_side_effect_test.rb

@@ -3,11 +3,9 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/change_state_side_effect'
 
 class ChangeStateSideEffectTest < Mocha::TestCase
-
   include Mocha
 
   class FakeState
-
     attr_reader :active
     attr_writer :description
 
@@ -18,7 +16,6 @@ class ChangeStateSideEffectTest < Mocha::TestCase
     def mocha_inspect
       @description
     end
-
   end
 
   def test_should_activate_the_given_state
@@ -37,5 +34,4 @@ class ChangeStateSideEffectTest < Mocha::TestCase
 
     assert_equal 'then the-new-state', side_effect.mocha_inspect
   end
-
 end

data/test/unit/class_method_test.rb

@@ -5,20 +5,19 @@ require 'mocha/mock'
 require 'mocha/class_method'
 
 class ClassMethodTest < Mocha::TestCase
-
   include Mocha
 
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
+  unless RUBY_V2_PLUS
+    def test_should_hide_original_method
+      klass = Class.new { def self.method_x; end }
+      klass.__metaclass__.send(:alias_method, :_method, :method)
+      method = ClassMethod.new(klass, :method_x)
 
-    method.hide_original_method
+      method.hide_original_method
 
-    assert_equal false, klass.respond_to?(:method_x)
+      assert_equal false, klass.respond_to?(:method_x)
+    end
   end
-end
 
   def test_should_not_raise_error_hiding_method_that_isnt_defined
     klass = Class.new
@@ -59,7 +58,11 @@ end
   end
 
   def test_should_restore_original_method
-    klass = Class.new { def self.method_x; :original_result; end }
+    klass = Class.new do
+      def self.method_x
+        :original_result
+      end
+    end
     klass.__metaclass__.send(:alias_method, :_method, :method)
     method = ClassMethod.new(klass, :method_x)
 
@@ -73,7 +76,11 @@ end
   end
 
   def test_should_restore_original_method_accepting_a_block_parameter
-    klass = Class.new { def self.method_x(&block); block.call if block_given? ; end }
+    klass = Class.new do
+      def self.method_x(&block)
+        block.call if block_given?
+      end
+    end
     klass.__metaclass__.send(:alias_method, :_method, :method)
     method = ClassMethod.new(klass, :method_x)
 
@@ -88,7 +95,11 @@ end
   end
 
   def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def self.method_x; :new_result; end }
+    klass = Class.new do
+      def self.method_x
+        :new_result
+      end
+    end
     method = ClassMethod.new(klass, :method_x)
 
     method.restore_original_method
@@ -124,7 +135,7 @@ end
     method = ClassMethod.new(klass, :method_x)
     mocha = build_mock
     klass.define_instance_method(:mocha) { mocha }
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:remove_called)
     method.replace_instance_method(:remove_new_method) { self.remove_called = true }
 
@@ -138,7 +149,7 @@ end
     mocha = build_mock
     klass.define_instance_method(:mocha) { mocha }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:reset_mocha) { }
+    method.replace_instance_method(:reset_mocha) {}
     method.define_instance_accessor(:restore_called)
     method.replace_instance_method(:restore_original_method) { self.restore_called = true }
 
@@ -150,8 +161,15 @@ end
   def test_should_call_mocha_unstub
     klass = Class.new { def self.method_x; end }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new { class << self; attr_accessor :unstub_method; end; def self.unstub(method); self.unstub_method = method; end; }
+    method.replace_instance_method(:restore_original_method) {}
+    mocha = Class.new do
+      class << self
+        attr_accessor :unstub_method
+      end
+      def self.unstub(method)
+        self.unstub_method = method
+      end
+    end
     mocha.define_instance_method(:any_expectations?) { true }
     method.replace_instance_method(:mock) { mocha }
 
@@ -162,13 +180,18 @@ end
   def test_should_call_stubbee_reset_mocha_if_no_expectations_remaining
     klass = Class.new { def self.method_x; end }
     method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
+    method.replace_instance_method(:remove_new_method) {}
+    method.replace_instance_method(:restore_original_method) {}
     mocha = Class.new
     mocha.define_instance_method(:unstub) { |method_name| }
     mocha.define_instance_method(:any_expectations?) { false }
     method.replace_instance_method(:mock) { mocha }
-    stubbee = Class.new { attr_accessor :reset_mocha_called; def reset_mocha; self.reset_mocha_called = true; end; }.new
+    stubbee = Class.new do
+      attr_accessor :reset_mocha_called
+      def reset_mocha
+        self.reset_mocha_called = true
+      end
+    end.new
     method.replace_instance_method(:stubbee) { stubbee }
 
     method.unstub
@@ -191,34 +214,36 @@ end
   end
 
   def test_should_not_match_if_other_class_method_has_different_stubbee
-    stubbee_1 = Object.new
-    stubbee_2 = Object.new
-    class_method_1 = ClassMethod.new(stubbee_1, :method)
-    class_method_2 = ClassMethod.new(stubbee_2, :method)
-    assert !class_method_1.matches?(class_method_2)
+    stubbee1 = Object.new
+    stubbee2 = Object.new
+    class_method1 = ClassMethod.new(stubbee1, :method)
+    class_method2 = ClassMethod.new(stubbee2, :method)
+    assert !class_method1.matches?(class_method2)
   end
 
   def test_should_not_match_if_other_class_method_has_different_method
     stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method_1)
-    class_method_2 = ClassMethod.new(stubbee, :method_2)
-    assert !class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method_1)
+    class_method2 = ClassMethod.new(stubbee, :method_2)
+    assert !class_method1.matches?(class_method2)
   end
 
   def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_so_no_attempt_is_made_to_stub_a_method_twice
     stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method)
+    class_method2 = ClassMethod.new(stubbee, :method)
+    assert class_method1.matches?(class_method2)
   end
 
   def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_but_stubbee_equal_method_lies_like_active_record_association_proxy
     stubbee = Class.new do
-      def equal?(other); false; end
+      def equal?(_other)
+        false
+      end
     end.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
+    class_method1 = ClassMethod.new(stubbee, :method)
+    class_method2 = ClassMethod.new(stubbee, :method)
+    assert class_method1.matches?(class_method2)
   end
 
   private

data/test/unit/class_methods_test.rb

@@ -5,7 +5,6 @@ require 'mocha/mockery'
 require 'mocha/names'
 
 class ClassMethodsTest < Mocha::TestCase
-
   def setup
     Mocha::Mockery.setup
     @klass = Class.new.extend(Mocha::ClassMethods, Mocha::ObjectMethods)
@@ -22,9 +21,9 @@ class ClassMethodsTest < Mocha::TestCase
   end
 
   def test_should_return_same_any_instance_object
-    any_instance_1 = @klass.any_instance
-    any_instance_2 = @klass.any_instance
-    assert_equal any_instance_1, any_instance_2
+    any_instance1 = @klass.any_instance
+    any_instance2 = @klass.any_instance
+    assert_equal any_instance1, any_instance2
   end
 
   def test_any_instance_should_build_mocha_referring_to_klass
@@ -40,15 +39,15 @@ class ClassMethodsTest < Mocha::TestCase
   end
 
   def test_any_instance_should_reuse_existing_mocha
-    mocha_1 = @klass.any_instance.mocha
-    mocha_2 = @klass.any_instance.mocha
-    assert_equal mocha_1, mocha_2
+    mocha1 = @klass.any_instance.mocha
+    mocha2 = @klass.any_instance.mocha
+    assert_equal mocha1, mocha2
   end
 
   def test_any_instance_should_reuse_existing_mocha_even_if_instantiate_is_false
-    mocha_1 = @klass.any_instance.mocha
-    mocha_2 = @klass.any_instance.mocha(false)
-    assert_equal mocha_1, mocha_2
+    mocha1 = @klass.any_instance.mocha
+    mocha2 = @klass.any_instance.mocha(false)
+    assert_equal mocha1, mocha2
   end
 
   def test_should_use_stubba_class_method_for_class
@@ -67,5 +66,4 @@ class ClassMethodsTest < Mocha::TestCase
     any_instance = @klass.any_instance
     assert_equal @klass, any_instance.stubba_object
   end
-
 end

data/test/unit/configuration_test.rb

@@ -1,5 +1,5 @@
 require File.expand_path('../../test_helper', __FILE__)
-require "mocha/configuration"
+require 'mocha/configuration'
 
 class ConfigurationTest < Mocha::TestCase
   def test_allow_temporarily_changes_config_when_given_block
@@ -35,4 +35,3 @@ class ConfigurationTest < Mocha::TestCase
     assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
   end
 end
-

data/test/unit/date_time_inspect_test.rb

@@ -2,7 +2,6 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/inspect'
 
 class DateTimeInspectTest < Mocha::TestCase
-
   def test_should_use_include_date_in_seconds
     time = Time.now
     assert_equal "#{time.inspect} (#{time.to_f} secs)", time.mocha_inspect
@@ -14,8 +13,7 @@ class DateTimeInspectTest < Mocha::TestCase
   end
 
   def test_should_use_to_s_for_datetime
-    datetime = DateTime.new(2006, 1, 1)
+    datetime = DateTime.new(2006, 1, 1) # rubocop:disable Style/DateTime
     assert_equal datetime.to_s, datetime.mocha_inspect
   end
-
 end

data/test/unit/exception_raiser_test.rb

@@ -4,7 +4,6 @@ require 'mocha/exception_raiser'
 require 'timeout'
 
 class ExceptionRaiserTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_raise_exception_with_specified_class_and_default_message
@@ -38,5 +37,4 @@ class ExceptionRaiserTest < Mocha::TestCase
     raiser = ExceptionRaiser.new(exception_class, nil)
     assert_raises(exception_class) { raiser.evaluate }
   end
-
 end

data/test/unit/expectation_list_test.rb

@@ -5,7 +5,6 @@ require 'set'
 require 'method_definer'
 
 class ExpectationListTest < Mocha::TestCase
-
   include Mocha
 
   def test_should_return_added_expectation
@@ -78,5 +77,4 @@ class ExpectationListTest < Mocha::TestCase
     expectation_list = expectation_list1 + expectation_list2
     assert_equal [expectation1, expectation2], expectation_list.to_a
   end
-
 end

data/test/unit/expectation_test.rb

@@ -6,7 +6,6 @@ require 'execution_point'
 require 'simple_counter'
 
 class ExpectationTest < Mocha::TestCase
-
   include Mocha
 
   def new_expectation
@@ -18,12 +17,12 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_match_calls_to_same_method_with_exactly_zero_parameters
-    expectation = new_expectation.with()
+    expectation = new_expectation.with
     assert expectation.match?(:expected_method)
   end
 
   def test_should_not_match_calls_to_same_method_with_more_than_zero_parameters
-    expectation = new_expectation.with()
+    expectation = new_expectation.with
     assert !expectation.match?(:expected_method, 1, 2, 3)
   end
 
@@ -33,12 +32,12 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_match_calls_to_same_method_with_parameters_constrained_as_expected
-    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    expectation = new_expectation.with { |x, y, z| x + y == z }
     assert expectation.match?(:expected_method, 1, 2, 3)
   end
 
   def test_should_not_match_calls_to_different_method_with_parameters_constrained_as_expected
-    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    expectation = new_expectation.with { |x, y, z| x + y == z }
     assert !expectation.match?(:different_method, 1, 2, 3)
   end
 
@@ -62,7 +61,7 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_not_match_calls_to_same_method_with_parameters_not_constrained_as_expected
-    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    expectation = new_expectation.with { |x, y, z| x + y == z }
     assert !expectation.match?(:expected_method, 1, 0, 3)
   end
 
@@ -99,51 +98,53 @@ class ExpectationTest < Mocha::TestCase
     assert_equal backtrace, expectation.backtrace
   end
 
+  # rubocop:disable Style/Semicolon
   def test_should_default_backtrace_to_caller
     execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
     assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
   end
+  # rubocop:enable Style/Semicolon
 
   def test_should_not_yield
     yielded = false
-    new_expectation.invoke() { yielded = true }
+    new_expectation.invoke { yielded = true }
     assert_equal false, yielded
   end
 
   def test_should_yield_no_parameters
-    expectation = new_expectation().yields()
+    expectation = new_expectation.yields
     yielded_parameters = nil
-    expectation.invoke() { |*parameters| yielded_parameters = parameters }
-    assert_equal Array.new, yielded_parameters
+    expectation.invoke { |*parameters| yielded_parameters = parameters }
+    assert_equal [], yielded_parameters
   end
 
   def test_should_yield_with_specified_parameters
-    expectation = new_expectation().yields(1, 2, 3)
+    expectation = new_expectation.yields(1, 2, 3)
     yielded_parameters = nil
-    expectation.invoke() { |*parameters| yielded_parameters = parameters }
+    expectation.invoke { |*parameters| yielded_parameters = parameters }
     assert_equal [1, 2, 3], yielded_parameters
   end
 
   def test_should_yield_different_parameters_on_consecutive_invocations
-    expectation = new_expectation().yields(1, 2, 3).yields(4, 5)
+    expectation = new_expectation.yields(1, 2, 3).yields(4, 5)
     yielded_parameters = []
-    expectation.invoke() { |*parameters| yielded_parameters << parameters }
-    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    expectation.invoke { |*parameters| yielded_parameters << parameters }
+    expectation.invoke { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
   end
 
   def test_should_yield_multiple_times_for_single_invocation
-    expectation = new_expectation().multiple_yields([1, 2, 3], [4, 5])
+    expectation = new_expectation.multiple_yields([1, 2, 3], [4, 5])
     yielded_parameters = []
-    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    expectation.invoke { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
   end
 
   def test_should_yield_multiple_times_for_first_invocation_and_once_for_second_invocation
-    expectation = new_expectation().multiple_yields([1, 2, 3], [4, 5]).then.yields(6, 7)
+    expectation = new_expectation.multiple_yields([1, 2, 3], [4, 5]).then.yields(6, 7)
     yielded_parameters = []
-    expectation.invoke() { |*parameters| yielded_parameters << parameters }
-    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    expectation.invoke { |*parameters| yielded_parameters << parameters }
+    expectation.invoke { |*parameters| yielded_parameters << parameters }
     assert_equal [[1, 2, 3], [4, 5], [6, 7]], yielded_parameters
   end
 
@@ -179,7 +180,7 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_return_nil_if_no_value_specified
-    expectation = new_expectation.returns()
+    expectation = new_expectation.returns
     assert_nil expectation.invoke
   end
 
@@ -209,21 +210,21 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_raise_custom_exception_with_message
-    exception_msg = "exception message"
+    exception_msg = 'exception message'
     expectation = new_expectation.raises(Exception, exception_msg)
     exception = assert_raise(Exception) { expectation.invoke }
     assert_equal exception_msg, exception.message
   end
 
   def test_should_return_values_then_raise_exception
-    expectation = new_expectation.returns(1, 2).then.raises()
+    expectation = new_expectation.returns(1, 2).then.raises
     assert_equal 1, expectation.invoke
     assert_equal 2, expectation.invoke
     assert_raise(RuntimeError) { expectation.invoke }
   end
 
   def test_should_raise_exception_then_return_values
-    expectation = new_expectation.raises().then.returns(1, 2)
+    expectation = new_expectation.raises.then.returns(1, 2)
     assert_raise(RuntimeError) { expectation.invoke }
     assert_equal 1, expectation.invoke
     assert_equal 2, expectation.invoke
@@ -276,7 +277,7 @@ class ExpectationTest < Mocha::TestCase
 
   def test_should_verify_successfully_if_expected_call_was_made_at_least_once
     expectation = new_expectation.at_least_once
-    3.times {expectation.invoke}
+    3.times { expectation.invoke }
     assert expectation.verified?
   end
 
@@ -288,20 +289,20 @@ class ExpectationTest < Mocha::TestCase
 
   def test_should_verify_successfully_if_expected_call_was_made_expected_number_of_times
     expectation = new_expectation.times(2)
-    2.times {expectation.invoke}
+    2.times { expectation.invoke }
     assert expectation.verified?
   end
 
   def test_should_not_verify_successfully_if_expected_call_was_made_too_few_times
     expectation = new_expectation.times(2)
-    1.times {expectation.invoke}
+    1.times { expectation.invoke }
     assert !expectation.verified?
     assert_match(/expected exactly twice, invoked once/i, expectation.mocha_inspect)
   end
 
   def test_should_not_verify_successfully_if_expected_call_was_made_too_many_times
     expectation = new_expectation.times(2)
-    3.times {expectation.invoke}
+    3.times { expectation.invoke }
     assert !expectation.verified?
   end
 
@@ -320,13 +321,14 @@ class ExpectationTest < Mocha::TestCase
     assert_equal 0, assertion_counter.count
   end
 
+  # rubocop:disable Style/Semicolon
   def test_should_store_backtrace_from_point_where_expectation_was_created
     execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
     assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
   end
+  # rubocop:enable Style/Semicolon
 
   class FakeMock
-
     def initialize(name)
       @name = name
     end
@@ -334,20 +336,18 @@ class ExpectationTest < Mocha::TestCase
     def mocha_inspect
       @name
     end
-
   end
 
   def test_should_raise_error_with_message_indicating_which_method_was_expected_to_be_called_on_which_mock_object_with_which_parameters_and_in_what_sequences
     mock = FakeMock.new('mock')
     sequence_one = Sequence.new('one')
     sequence_two = Sequence.new('two')
-    expectation = Expectation.new(mock, :expected_method).with(1, 2, {'a' => true}, {:b => false}, [1, 2, 3]).in_sequence(sequence_one, sequence_two)
+    expectation = Expectation.new(mock, :expected_method).with(1, 2, { 'a' => true }, { :b => false }, [1, 2, 3]).in_sequence(sequence_one, sequence_two)
     assert !expectation.verified?
     assert_match %{mock.expected_method(1, 2, {"a" => true}, {:b => false}, [1, 2, 3]); in sequence "one"; in sequence "two"}, expectation.mocha_inspect
   end
 
   class FakeConstraint
-
     def initialize(allows_invocation_now)
       @allows_invocation_now = allows_invocation_now
     end
@@ -355,12 +355,11 @@ class ExpectationTest < Mocha::TestCase
     def allows_invocation_now?
       @allows_invocation_now
     end
-
   end
 
   def test_should_be_in_correct_order_if_all_ordering_constraints_allow_invocation_now
-    constraint_one = FakeConstraint.new(allows_invocation_now = true)
-    constraint_two = FakeConstraint.new(allows_invocation_now = true)
+    constraint_one = FakeConstraint.new(true)
+    constraint_two = FakeConstraint.new(true)
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
@@ -368,8 +367,8 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_not_be_in_correct_order_if_one_ordering_constraint_does_not_allow_invocation_now
-    constraint_one = FakeConstraint.new(allows_invocation_now = true)
-    constraint_two = FakeConstraint.new(allows_invocation_now = false)
+    constraint_one = FakeConstraint.new(true)
+    constraint_two = FakeConstraint.new(false)
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
@@ -377,8 +376,8 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_match_if_all_ordering_constraints_allow_invocation_now
-    constraint_one = FakeConstraint.new(allows_invocation_now = true)
-    constraint_two = FakeConstraint.new(allows_invocation_now = true)
+    constraint_one = FakeConstraint.new(true)
+    constraint_two = FakeConstraint.new(true)
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
@@ -386,8 +385,8 @@ class ExpectationTest < Mocha::TestCase
   end
 
   def test_should_not_match_if_one_ordering_constraints_does_not_allow_invocation_now
-    constraint_one = FakeConstraint.new(allows_invocation_now = true)
-    constraint_two = FakeConstraint.new(allows_invocation_now = false)
+    constraint_one = FakeConstraint.new(true)
+    constraint_two = FakeConstraint.new(false)
     expectation = Expectation.new(nil, :method_one)
     expectation.add_ordering_constraint(constraint_one)
     expectation.add_ordering_constraint(constraint_two)
@@ -418,7 +417,6 @@ class ExpectationTest < Mocha::TestCase
   end
 
   class FakeSequence
-
     attr_reader :expectations
 
     def initialize
@@ -428,7 +426,6 @@ class ExpectationTest < Mocha::TestCase
     def constrain_as_next_in_sequence(expectation)
       @expectations << expectation
     end
-
   end
 
   def test_should_tell_sequences_to_constrain_expectation_as_next_in_sequence
@@ -441,7 +438,6 @@ class ExpectationTest < Mocha::TestCase
   end
 
   class FakeState
-
     def initialize
       @active = false
     end
@@ -453,7 +449,6 @@ class ExpectationTest < Mocha::TestCase
     def active?
       @active
     end
-
   end
 
   def test_should_change_state_when_expectation_is_invoked
@@ -483,7 +478,7 @@ class ExpectationTest < Mocha::TestCase
       define_method(:inspect) { 'mock' }
     end
     expectation = Expectation.new(object, :method_one)
-    assert_match Regexp.new("^#<Expectation:0x[0-9A-Fa-f]{1,12} .* >$"), expectation.inspect
+    assert_match Regexp.new('^#<Expectation:0x[0-9A-Fa-f]{1,12} .* >$'), expectation.inspect
   end
 
   def test_should_include_output_of_mocha_inspect_in_inspect