xqsr3 0.38.2 → 0.39.2

data/test/unit/conversion/tc_integer_parser.rb

@@ -10,101 +10,101 @@ require 'test/unit'
 
 class Test_IntegerParser < Test::Unit::TestCase
 
-	IP = ::Xqsr3::Conversion::IntegerParser
+  IP = ::Xqsr3::Conversion::IntegerParser
 
-	class SomeRandomException < Exception; end
+  class SomeRandomException < Exception; end
 
-	def test_show_base_being_ignored
+  def test_show_base_being_ignored
 
-		assert_equal -100, IP.to_integer(-100)
-		assert_equal -100, IP.to_integer(-100, 0)
-		assert_equal -100, IP.to_integer(-100.0, 0)
-		assert_equal -100, IP.to_integer(-100.0, 10)
+    assert_equal(-100, IP.to_integer(-100))
+    assert_equal(-100, IP.to_integer(-100, 0))
+    assert_equal(-100, IP.to_integer(-100.0, 0))
+    assert_equal(-100, IP.to_integer(-100.0, 10))
 
-		assert_equal -100, IP.to_integer('-100')
-		assert_equal -100, IP.to_integer('-100', 0)
-		assert_equal -100, IP.to_integer('-100', 10)
-		assert_equal -4, IP.to_integer('-100', 2)
-	end
+    assert_equal(-100, IP.to_integer('-100'))
+    assert_equal(-100, IP.to_integer('-100', 0))
+    assert_equal(-100, IP.to_integer('-100', 10))
+    assert_equal(-4, IP.to_integer('-100', 2))
+  end
 
-	def test_default_for_invalid_type
+  def test_default_for_invalid_type
 
-		assert_equal 12345, IP.to_integer(12..345, default: 12345)
-	end
+    assert_equal 12345, IP.to_integer(12..345, default: 12345)
+  end
 
-	def test_to_integer_with_valid_values
+  def test_to_integer_with_valid_values
 
-		assert_equal 0, IP.to_integer(0)
-		assert_equal +1, IP.to_integer(1)
-		assert_equal +1, IP.to_integer(+1)
-		assert_equal -1, IP.to_integer(-1)
+    assert_equal(0, IP.to_integer(0))
+    assert_equal(+1, IP.to_integer(1))
+    assert_equal(+1, IP.to_integer(+1))
+    assert_equal(-1, IP.to_integer(-1))
 
-		assert_equal 0, IP.to_integer('0')
-		assert_equal +1, IP.to_integer('1')
-		assert_equal +1, IP.to_integer('+1')
-		assert_equal -1, IP.to_integer('-1')
-	end
+    assert_equal(0, IP.to_integer('0'))
+    assert_equal(+1, IP.to_integer('1'))
+    assert_equal(+1, IP.to_integer('+1'))
+    assert_equal(-1, IP.to_integer('-1'))
+  end
 
-	def test_to_integer_with_invalid_values
+  def test_to_integer_with_invalid_values
 
-		assert_raise(TypeError) { IP.to_integer nil }
-		assert_raise(ArgumentError) { IP.to_integer '' }
-		assert_raise(ArgumentError) { IP.to_integer 'abc' }
-		assert_raise(ArgumentError) { IP.to_integer 'zero' }
-		assert_raise(ArgumentError) { IP.to_integer 'plus 1' }
-		assert_raise(ArgumentError) { IP.to_integer '/0' }
-	end
+    assert_raise(TypeError) { IP.to_integer nil }
+    assert_raise(ArgumentError) { IP.to_integer '' }
+    assert_raise(ArgumentError) { IP.to_integer 'abc' }
+    assert_raise(ArgumentError) { IP.to_integer 'zero' }
+    assert_raise(ArgumentError) { IP.to_integer 'plus 1' }
+    assert_raise(ArgumentError) { IP.to_integer '/0' }
+  end
 
-	def test_to_integer_with_invalid_values_returning_nil
+  def test_to_integer_with_invalid_values_returning_nil
 
-		assert_nil IP.to_integer(nil, nil: true)
-		assert_nil IP.to_integer('', nil: true)
-		assert_nil IP.to_integer('abc', nil: true)
-		assert_nil IP.to_integer('zero', nil: true)
-		assert_nil IP.to_integer('plus 1', nil: true)
-		assert_nil IP.to_integer('/0', nil: true)
-	end
+    assert_nil IP.to_integer(nil, nil: true)
+    assert_nil IP.to_integer('', nil: true)
+    assert_nil IP.to_integer('abc', nil: true)
+    assert_nil IP.to_integer('zero', nil: true)
+    assert_nil IP.to_integer('plus 1', nil: true)
+    assert_nil IP.to_integer('/0', nil: true)
+  end
 
-	def test_to_integer_with_invalid_values_returning_0
+  def test_to_integer_with_invalid_values_returning_0
 
-		assert_equal 0, IP.to_integer(nil, default: 0)
-		assert_equal 0, IP.to_integer('', default: 0)
-		assert_equal 0, IP.to_integer('abc', default: 0)
-		assert_equal 0, IP.to_integer('zero', default: 0)
-		assert_equal 0, IP.to_integer('plus 1', default: 0)
-		assert_equal 0, IP.to_integer('/0', default: 0)
-	end
+    assert_equal 0, IP.to_integer(nil, default: 0)
+    assert_equal 0, IP.to_integer('', default: 0)
+    assert_equal 0, IP.to_integer('abc', default: 0)
+    assert_equal 0, IP.to_integer('zero', default: 0)
+    assert_equal 0, IP.to_integer('plus 1', default: 0)
+    assert_equal 0, IP.to_integer('/0', default: 0)
+  end
 
-	def test_to_integer_with_invalid_values_returning_sentinel
+  def test_to_integer_with_invalid_values_returning_sentinel
 
-		assert_equal :sentinel, IP.to_integer(nil, default: :sentinel)
-		assert_equal :sentinel, IP.to_integer('', default: :sentinel)
-		assert_equal :sentinel, IP.to_integer('abc', default: :sentinel)
-		assert_equal :sentinel, IP.to_integer('zero', default: :sentinel)
-		assert_equal :sentinel, IP.to_integer('plus 1', default: :sentinel)
-		assert_equal :sentinel, IP.to_integer('/0', default: :sentinel)
-	end
+    assert_equal :sentinel, IP.to_integer(nil, default: :sentinel)
+    assert_equal :sentinel, IP.to_integer('', default: :sentinel)
+    assert_equal :sentinel, IP.to_integer('abc', default: :sentinel)
+    assert_equal :sentinel, IP.to_integer('zero', default: :sentinel)
+    assert_equal :sentinel, IP.to_integer('plus 1', default: :sentinel)
+    assert_equal :sentinel, IP.to_integer('/0', default: :sentinel)
+  end
 
-	def test_to_integer_with_invalid_values_returning_sentinel_of_nil
+  def test_to_integer_with_invalid_values_returning_sentinel_of_nil
 
-		assert_equal nil, IP.to_integer(nil, default: nil)
-		assert_equal nil, IP.to_integer('', default: nil)
-		assert_equal nil, IP.to_integer('abc', default: nil)
-		assert_equal nil, IP.to_integer('zero', default: nil)
-		assert_equal nil, IP.to_integer('plus 1', default: nil)
-		assert_equal nil, IP.to_integer('/0', default: nil)
-	end
+    assert_equal nil, IP.to_integer(nil, default: nil)
+    assert_equal nil, IP.to_integer('', default: nil)
+    assert_equal nil, IP.to_integer('abc', default: nil)
+    assert_equal nil, IP.to_integer('zero', default: nil)
+    assert_equal nil, IP.to_integer('plus 1', default: nil)
+    assert_equal nil, IP.to_integer('/0', default: nil)
+  end
 
-	def test_to_integer_with_invalid_values_and_block
+  def test_to_integer_with_invalid_values_and_block
 
-		assert_equal nil, IP.to_integer(nil) { nil }
-		assert_equal nil, IP.to_integer('blah') { nil }
+    assert_equal nil, IP.to_integer(nil) { nil }
+    assert_equal nil, IP.to_integer('blah') { nil }
 
-		assert_equal 'one', IP.to_integer(nil) { 'one' }
-		assert_equal 'one', IP.to_integer('blah') { 'one' }
+    assert_equal 'one', IP.to_integer(nil) { 'one' }
+    assert_equal 'one', IP.to_integer('blah') { 'one' }
 
-		assert_raise(SomeRandomException) { IP.to_integer(nil) { raise SomeRandomException.new } }
-	end
+    assert_raise(SomeRandomException) { IP.to_integer(nil) { raise SomeRandomException.new } }
+  end
 end
 
 

data/test/unit/conversion/tc_to_bool.rb

@@ -9,38 +9,38 @@ require 'test/unit'
 
 class Test_Xqsr3_ConversionMultiMap < Test::Unit::TestCase
 
-	include ::Xqsr3::Conversion
+  include ::Xqsr3::Conversion
 
-	def test_parse_normal
+  def test_parse_normal
 
-		assert_true BoolParser.to_bool 'true'
-		assert_false BoolParser.to_bool 'false'
-	end
+    assert_true BoolParser.to_bool 'true'
+    assert_false BoolParser.to_bool 'false'
+  end
 
-	def test_parse_custom_true_false
+  def test_parse_custom_true_false
 
-		true_values		=	[ 'affirmative', 'yup' ]
-		false_values	=	[ 'negative', 'nope' ]
+    true_values   = [ 'affirmative', 'yup' ]
+    false_values  = [ 'negative', 'nope' ]
 
-		assert_true BoolParser.to_bool 'affirmative', true_values: true_values, false_values: false_values
-		assert_true BoolParser.to_bool 'yup', true_values: true_values, false_values: false_values
-		assert_nil BoolParser.to_bool 'true', true_values: true_values, false_values: false_values
-		assert_false BoolParser.to_bool 'negative', true_values: true_values, false_values: false_values
-		assert_false BoolParser.to_bool 'nope', true_values: true_values, false_values: false_values
-		assert_nil BoolParser.to_bool 'false', true_values: true_values, false_values: false_values
-	end
+    assert_true BoolParser.to_bool 'affirmative', true_values: true_values, false_values: false_values
+    assert_true BoolParser.to_bool 'yup', true_values: true_values, false_values: false_values
+    assert_nil BoolParser.to_bool 'true', true_values: true_values, false_values: false_values
+    assert_false BoolParser.to_bool 'negative', true_values: true_values, false_values: false_values
+    assert_false BoolParser.to_bool 'nope', true_values: true_values, false_values: false_values
+    assert_nil BoolParser.to_bool 'false', true_values: true_values, false_values: false_values
+  end
 
-	def test_parse_custom_true_false_regexes
+  def test_parse_custom_true_false_regexes
 
-		true_values		=	[ /affirm/, /yup/ ]
-		false_values	=	[ 'negative', /no/ ]
+    true_values   = [ /affirm/, /yup/ ]
+    false_values  = [ 'negative', /no/ ]
 
-		assert_true BoolParser.to_bool 'affirmative', true_values: true_values, false_values: false_values
-		assert_true BoolParser.to_bool 'yup', true_values: true_values, false_values: false_values
-		assert_nil BoolParser.to_bool 'true', true_values: true_values, false_values: false_values
-		assert_false BoolParser.to_bool 'negative', true_values: true_values, false_values: false_values
-		assert_false BoolParser.to_bool 'nope', true_values: true_values, false_values: false_values
-		assert_nil BoolParser.to_bool 'false', true_values: true_values, false_values: false_values
-	end
+    assert_true BoolParser.to_bool 'affirmative', true_values: true_values, false_values: false_values
+    assert_true BoolParser.to_bool 'yup', true_values: true_values, false_values: false_values
+    assert_nil BoolParser.to_bool 'true', true_values: true_values, false_values: false_values
+    assert_false BoolParser.to_bool 'negative', true_values: true_values, false_values: false_values
+    assert_false BoolParser.to_bool 'nope', true_values: true_values, false_values: false_values
+    assert_nil BoolParser.to_bool 'false', true_values: true_values, false_values: false_values
+  end
 end
 

data/test/unit/diagnostics/exceptions/tc_with_cause.rb

@@ -8,255 +8,255 @@ require 'test/unit'
 
 class Test_WithCause < Test::Unit::TestCase
 
-	class SomeExceptionWithCause < ::Exception
+  class SomeExceptionWithCause < ::Exception
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
-	end
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
+  end
 
-	def test_no_ctor_args
+  def test_no_ctor_args
 
-		x = SomeExceptionWithCause.new
+    x = SomeExceptionWithCause.new
 
-		assert_nil x.cause
-		assert_equal SomeExceptionWithCause.to_s, x.message
-		assert_equal SomeExceptionWithCause.to_s, x.chained_message
-		assert_empty x.chainees
-		assert_equal [ x ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_nil x.cause
+    assert_equal SomeExceptionWithCause.to_s, x.message
+    assert_equal SomeExceptionWithCause.to_s, x.chained_message
+    assert_empty x.chainees
+    assert_equal [ x ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_1_ctor_arg_that_is_a_message
+  def test_1_ctor_arg_that_is_a_message
 
-		msg = 'stuff'
+    msg = 'stuff'
 
-		x = SomeExceptionWithCause.new msg
+    x = SomeExceptionWithCause.new msg
 
-		assert_nil x.cause
-		assert_equal msg, x.message
-		assert_equal msg, x.chained_message
-		assert_empty x.chainees
-		assert_equal [ x ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_nil x.cause
+    assert_equal msg, x.message
+    assert_equal msg, x.chained_message
+    assert_empty x.chainees
+    assert_equal [ x ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_1_ctor_arg_that_is_a_cause_and_has_no_message
+  def test_1_ctor_arg_that_is_a_cause_and_has_no_message
 
-		c = RuntimeError.new
+    c = RuntimeError.new
 
-		x = SomeExceptionWithCause.new c
+    x = SomeExceptionWithCause.new c
 
-		assert_not_nil x.cause
-		assert_equal SomeExceptionWithCause.to_s, x.message
-		assert_equal "#{SomeExceptionWithCause.to_s}: #{RuntimeError.to_s}", x.chained_message
-		assert_not_empty x.chainees
-		assert_equal [ c ], x.chainees
-		assert_equal [ x, c ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_not_nil x.cause
+    assert_equal SomeExceptionWithCause.to_s, x.message
+    assert_equal "#{SomeExceptionWithCause.to_s}: #{RuntimeError.to_s}", x.chained_message
+    assert_not_empty x.chainees
+    assert_equal [ c ], x.chainees
+    assert_equal [ x, c ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_1_ctor_arg_that_is_a_cause_and_has_a_message
+  def test_1_ctor_arg_that_is_a_cause_and_has_a_message
 
-		c = RuntimeError.new 'blah'
+    c = RuntimeError.new 'blah'
 
-		x = SomeExceptionWithCause.new c
+    x = SomeExceptionWithCause.new c
 
-		assert_not_nil x.cause
-		assert_equal 'blah', x.message
-		assert_equal 'blah', x.chained_message
-		assert_not_empty x.chainees
-		assert_equal [ c ], x.chainees
-		assert_equal [ x, c ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_not_nil x.cause
+    assert_equal 'blah', x.message
+    assert_equal 'blah', x.chained_message
+    assert_not_empty x.chainees
+    assert_equal [ c ], x.chainees
+    assert_equal [ x, c ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_2_ctor_args_that_are_message_and_cause
+  def test_2_ctor_args_that_are_message_and_cause
 
-		msg = 'stuff'
+    msg = 'stuff'
 
-		c = RuntimeError.new
+    c = RuntimeError.new
 
-		x = SomeExceptionWithCause.new msg, c
+    x = SomeExceptionWithCause.new msg, c
 
-		assert_not_nil x.cause
-		assert_equal msg, x.message
-		assert_equal "#{msg}: #{RuntimeError.to_s}", x.chained_message
-		assert_not_empty x.chainees
-		assert_equal [ c ], x.chainees
-		assert_equal [ x, c ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_not_nil x.cause
+    assert_equal msg, x.message
+    assert_equal "#{msg}: #{RuntimeError.to_s}", x.chained_message
+    assert_not_empty x.chainees
+    assert_equal [ c ], x.chainees
+    assert_equal [ x, c ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_2_ctor_args_that_are_message_and_cause_that_has_a_message
+  def test_2_ctor_args_that_are_message_and_cause_that_has_a_message
 
-		msg = 'stuff'
+    msg = 'stuff'
 
-		c = RuntimeError.new 'blah'
+    c = RuntimeError.new 'blah'
 
-		x = SomeExceptionWithCause.new msg, c
+    x = SomeExceptionWithCause.new msg, c
 
-		assert_not_nil x.cause
-		assert_equal msg, x.message
-		assert_equal 'stuff: blah', x.chained_message
+    assert_not_nil x.cause
+    assert_equal msg, x.message
+    assert_equal 'stuff: blah', x.chained_message
 
-		assert_not_empty x.chainees
-		assert_equal [ c ], x.chainees
-		assert_equal [ x, c ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_not_empty x.chainees
+    assert_equal [ c ], x.chainees
+    assert_equal [ x, c ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
-	def test_cause_in_options
+  def test_cause_in_options
 
-		c = RuntimeError.new 'inner'
+    c = RuntimeError.new 'inner'
 
-		x = SomeExceptionWithCause.new 'outer', cause: c
+    x = SomeExceptionWithCause.new 'outer', cause: c
 
-		assert_not_nil x.cause
-		assert_equal 'outer', x.message
-		assert_equal 'outer: inner', x.chained_message
+    assert_not_nil x.cause
+    assert_equal 'outer', x.message
+    assert_equal 'outer: inner', x.chained_message
 
-		assert_not_empty x.chainees
-		assert_equal [ c ], x.chainees
-		assert_equal [ x, c ], x.exceptions
-		assert_nil x.backtrace
-		assert_empty x.options
-	end
+    assert_not_empty x.chainees
+    assert_equal [ c ], x.chainees
+    assert_equal [ x, c ], x.exceptions
+    assert_nil x.backtrace
+    assert_empty x.options
+  end
 
 
 
-	class GrandchildException < Exception
+  class GrandchildException < Exception
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
-	end
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
+  end
 
-	class ChildException < Exception
+  class ChildException < Exception
 
-		def initialize(*args, **options)
+    def initialize(*args, **options)
 
-			super *args, **options
-		end
+      super(*args, **options)
+    end
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
-	end
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
+  end
 
-	class ParentException < Exception
+  class ParentException < Exception
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
 
-		def initialize(*args, **options)
+    def initialize(*args, **options)
 
-			super *args, **options
-		end
-	end
+      super(*args, **options)
+    end
+  end
 
-	class GrandparentException < Exception
+  class GrandparentException < Exception
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
-	end
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
+  end
 
 
-	def test_four_levels
+  def test_four_levels
 
-		gc = GrandchildException.new 'gc'
+    gc = GrandchildException.new 'gc'
 
-		c = ChildException.new 'c', gc
+    c = ChildException.new 'c', gc
 
-		p = ParentException.new c, 'p'
+    p = ParentException.new c, 'p'
 
-		gp = GrandparentException.new 'gp', cause: p
+    gp = GrandparentException.new 'gp', cause: p
 
-		assert_equal 'gp: p: c: gc', gp.chained_message
-		assert_equal 'gp-p-c-gc', gp.chained_message(separator: '-')
-	end
+    assert_equal 'gp: p: c: gc', gp.chained_message
+    assert_equal 'gp-p-c-gc', gp.chained_message(separator: '-')
+  end
 end
 
 class Test_WithCause_throwing < Test::Unit::TestCase
 
-	class SomeExceptionWithCause < ::Exception
+  class SomeExceptionWithCause < ::Exception
 
-		include ::Xqsr3::Diagnostics::Exceptions::WithCause
-	end
+    include ::Xqsr3::Diagnostics::Exceptions::WithCause
+  end
 
-	def f m
+  def f m
 
-		raise SomeExceptionWithCause, m
-	end
+    raise SomeExceptionWithCause, m
+  end
 
-	def g m, n
+  def g m, n
 
-		begin
+    begin
 
-			f n
-		rescue Exception => x
+      f n
+    rescue Exception => x
 
-			raise SomeExceptionWithCause.new m, x
-		end
-	end
+      raise SomeExceptionWithCause.new m, x
+    end
+  end
 
-	def h m, n, o
+  def h m, n, o
 
-		begin
+    begin
 
-			g n, 0
-		rescue Exception => x
+      g n, 0
+    rescue Exception => x
 
-			raise SomeExceptionWithCause.new m, x
-		end
-	end
+      raise SomeExceptionWithCause.new m, x
+    end
+  end
 
-	def test_one_level
+  def test_one_level
 
-		begin
+    begin
 
-			f 'one-level'
+      f 'one-level'
 
-			assert false, 'should not get here!'
-		rescue Exception => x
+      assert false, 'should not get here!'
+    rescue Exception => x
 
-			assert_nil x.cause
-			assert_equal 'one-level', x.message
-			assert_equal 'one-level', x.chained_message
-			assert_empty x.chainees
-			assert_not_empty x.backtrace
+      assert_nil x.cause
+      assert_equal 'one-level', x.message
+      assert_equal 'one-level', x.chained_message
+      assert_empty x.chainees
+      assert_not_empty x.backtrace
 
-			x_bt0 = x.backtrace[0]
+      x_bt0 = x.backtrace[0]
 
-			assert /:in\s+\`f\'\s*$/ =~ x_bt0, 'not receieved from f()'
-		end
-	end
+      assert (/:in\s+\`f\'\s*$/ =~ x_bt0), 'not receieved from f()'
+    end
+  end
 
-	def test_two_levels
+  def test_two_levels
 
-		begin
+    begin
 
-			g 'two-levels', 'one-level'
+      g 'two-levels', 'one-level'
 
-			assert false, 'should not get here!'
-		rescue Exception => x
+      assert false, 'should not get here!'
+    rescue Exception => x
 
-			assert_not_nil x.cause
-			assert_equal 'two-levels', x.message
-			assert_equal 'two-levels: one-level', x.chained_message
-			assert_not_empty x.chainees
-			assert_kind_of SomeExceptionWithCause, x.chainees[0]
-			assert_not_empty x.backtrace
-			assert_not_empty x.cause.backtrace
+      assert_not_nil x.cause
+      assert_equal 'two-levels', x.message
+      assert_equal 'two-levels: one-level', x.chained_message
+      assert_not_empty x.chainees
+      assert_kind_of SomeExceptionWithCause, x.chainees[0]
+      assert_not_empty x.backtrace
+      assert_not_empty x.cause.backtrace
 
-			x_bt0 = x.backtrace[0]
+      x_bt0 = x.backtrace[0]
 
-			assert /:in\s+\`rescue in g\'\s*$/ =~ x_bt0, 'not receieved from g()'
+      assert (/:in\s+\`rescue in g\'\s*$/ =~ x_bt0), 'not receieved from g()'
 
-			c_bt0 = x.cause.backtrace[0]
+      c_bt0 = x.cause.backtrace[0]
 
-			assert /:in\s+\`f\'\s*$/ =~ c_bt0, 'not receieved from f()'
+      assert (/:in\s+\`f\'\s*$/ =~ c_bt0), 'not receieved from f()'
 
-			assert_not_empty x.chained_backtrace
-		end
-	end
+      assert_not_empty x.chained_backtrace
+    end
+  end
 end