opal-activesupport 0.2.0 → 0.3.0

data/{spec/core_ext/numeric_spec.rb → test/core_ext/numeric_ext_test.rb}

@@ -1,13 +1,15 @@
-require 'spec_helper'
-# require 'active_support/time'
+require 'abstract_unit'
+require 'active_support/time'
 require 'active_support/core_ext/numeric'
 require 'active_support/core_ext/integer'
 
-describe 'Numeric' do
-  before do
-    # @now = Time.local(2005,2,10,15,30,45)
-    @now = Time.mktime(2005,2,10,15,30,45)
-    # @dtnow = DateTime.civil(2005,2,10,15,30,45)
+class DateTime < Date
+end unless defined? DateTime
+
+class NumericExtTimeAndDateTimeTest < ActiveSupport::TestCase
+  def setup
+    @now = Time.local(2005,2,10,15,30,45)
+    @dtnow = DateTime.civil(2005,2,10,15,30,45)
     @seconds = {
       1.minute   => 60,
       10.minutes => 600,
@@ -17,126 +19,118 @@ describe 'Numeric' do
     }
   end
 
-  it 'has time units' do
+  def test_units
     @seconds.each do |actual, expected|
-      actual.should == expected
+      assert_equal expected, actual
     end
   end
 
-  it 'has intervals' do
+  def test_intervals
     @seconds.values.each do |seconds|
       assert_equal seconds.since(@now), @now + seconds
       assert_equal seconds.until(@now), @now - seconds
     end
   end
+
+  # # Test intervals based from Time.now
+  # def test_now
+  #   @seconds.values.each do |seconds|
+  #     now = Time.now
+  #     assert seconds.ago >= now - seconds
+  #     now = Time.now
+  #     assert seconds.from_now >= now + seconds
+  #   end
+  # end
+  #
+  # def test_irregular_durations
+  #   assert_equal @now.advance(:days => 3000), 3000.days.since(@now)
+  #   assert_equal @now.advance(:months => 1), 1.month.since(@now)
+  #   assert_equal @now.advance(:months => -1), 1.month.until(@now)
+  #   assert_equal @now.advance(:years => 20), 20.years.since(@now)
+  #   assert_equal @dtnow.advance(:days => 3000), 3000.days.since(@dtnow)
+  #   assert_equal @dtnow.advance(:months => 1), 1.month.since(@dtnow)
+  #   assert_equal @dtnow.advance(:months => -1), 1.month.until(@dtnow)
+  #   assert_equal @dtnow.advance(:years => 20), 20.years.since(@dtnow)
+  # end
+  #
+  # def test_duration_addition
+  #   assert_equal @now.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@now)
+  #   assert_equal @now.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@now)
+  #   assert_equal @now.advance(:years => 2), (4.years - 2.years).since(@now)
+  #   assert_equal @dtnow.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@dtnow)
+  #   assert_equal @dtnow.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
+  #   assert_equal @dtnow.advance(:years => 2), (4.years - 2.years).since(@dtnow)
+  # end
+  #
+  # def test_time_plus_duration
+  #   assert_equal @now + 8, @now + 8.seconds
+  #   assert_equal @now + 22.9, @now + 22.9.seconds
+  #   assert_equal @now.advance(:days => 15), @now + 15.days
+  #   assert_equal @now.advance(:months => 1), @now + 1.month
+  #   assert_equal @dtnow.since(8), @dtnow + 8.seconds
+  #   assert_equal @dtnow.since(22.9), @dtnow + 22.9.seconds
+  #   assert_equal @dtnow.advance(:days => 15), @dtnow + 15.days
+  #   assert_equal @dtnow.advance(:months => 1), @dtnow + 1.month
+  # end
+  #
+  # def test_chaining_duration_operations
+  #   assert_equal @now.advance(:days => 2).advance(:months => -3), @now + 2.days - 3.months
+  #   assert_equal @now.advance(:days => 1).advance(:months => 2), @now + 1.day + 2.months
+  #   assert_equal @dtnow.advance(:days => 2).advance(:months => -3), @dtnow + 2.days - 3.months
+  #   assert_equal @dtnow.advance(:days => 1).advance(:months => 2), @dtnow + 1.day + 2.months
+  # end
+  #
+  # def test_duration_after_convertion_is_no_longer_accurate
+  #   assert_equal 30.days.to_i.since(@now), 1.month.to_i.since(@now)
+  #   assert_equal 365.25.days.to_f.since(@now), 1.year.to_f.since(@now)
+  #   assert_equal 30.days.to_i.since(@dtnow), 1.month.to_i.since(@dtnow)
+  #   assert_equal 365.25.days.to_f.since(@dtnow), 1.year.to_f.since(@dtnow)
+  # end
+  #
+  # def test_add_one_year_to_leap_day
+  #   assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10) + 1.year
+  #   assert_equal DateTime.civil(2005,2,28,15,15,10), DateTime.civil(2004,2,29,15,15,10) + 1.year
+  # end
+  #
+  # def test_since_and_ago_anchored_to_time_now_when_time_zone_is_not_set
+  #   Time.zone = nil
+  #   with_env_tz 'US/Eastern' do
+  #     Time.stubs(:now).returns Time.local(2000)
+  #     # since
+  #     assert_equal false, 5.since.is_a?(ActiveSupport::TimeWithZone)
+  #     assert_equal Time.local(2000,1,1,0,0,5), 5.since
+  #     # ago
+  #     assert_equal false, 5.ago.is_a?(ActiveSupport::TimeWithZone)
+  #     assert_equal Time.local(1999,12,31,23,59,55), 5.ago
+  #   end
+  # end
+  #
+  # def test_since_and_ago_anchored_to_time_zone_now_when_time_zone_is_set
+  #   Time.zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
+  #   with_env_tz 'US/Eastern' do
+  #     Time.stubs(:now).returns Time.local(2000)
+  #     # since
+  #     assert_equal true, 5.since.is_a?(ActiveSupport::TimeWithZone)
+  #     assert_equal Time.utc(2000,1,1,0,0,5), 5.since.time
+  #     assert_equal 'Eastern Time (US & Canada)', 5.since.time_zone.name
+  #     # ago
+  #     assert_equal true, 5.ago.is_a?(ActiveSupport::TimeWithZone)
+  #     assert_equal Time.utc(1999,12,31,23,59,55), 5.ago.time
+  #     assert_equal 'Eastern Time (US & Canada)', 5.ago.time_zone.name
+  #   end
+  # ensure
+  #   Time.zone = nil
+  # end
+  #
+  # protected
+  #   def with_env_tz(new_tz = 'US/Eastern')
+  #     old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+  #     yield
+  #   ensure
+  #     old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+  #   end
 end
 
-#   def test_intervals
-#     @seconds.values.each do |seconds|
-#       assert_equal seconds.since(@now), @now + seconds
-#       assert_equal seconds.until(@now), @now - seconds
-#     end
-#   end
-#
-#   # Test intervals based from Time.now
-#   def test_now
-#     @seconds.values.each do |seconds|
-#       now = Time.now
-#       assert seconds.ago >= now - seconds
-#       now = Time.now
-#       assert seconds.from_now >= now + seconds
-#     end
-#   end
-#
-#   def test_irregular_durations
-#     assert_equal @now.advance(:days => 3000), 3000.days.since(@now)
-#     assert_equal @now.advance(:months => 1), 1.month.since(@now)
-#     assert_equal @now.advance(:months => -1), 1.month.until(@now)
-#     assert_equal @now.advance(:years => 20), 20.years.since(@now)
-#     assert_equal @dtnow.advance(:days => 3000), 3000.days.since(@dtnow)
-#     assert_equal @dtnow.advance(:months => 1), 1.month.since(@dtnow)
-#     assert_equal @dtnow.advance(:months => -1), 1.month.until(@dtnow)
-#     assert_equal @dtnow.advance(:years => 20), 20.years.since(@dtnow)
-#   end
-#
-#   def test_duration_addition
-#     assert_equal @now.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@now)
-#     assert_equal @now.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@now)
-#     assert_equal @now.advance(:years => 2), (4.years - 2.years).since(@now)
-#     assert_equal @dtnow.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@dtnow)
-#     assert_equal @dtnow.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
-#     assert_equal @dtnow.advance(:years => 2), (4.years - 2.years).since(@dtnow)
-#   end
-#
-#   def test_time_plus_duration
-#     assert_equal @now + 8, @now + 8.seconds
-#     assert_equal @now + 22.9, @now + 22.9.seconds
-#     assert_equal @now.advance(:days => 15), @now + 15.days
-#     assert_equal @now.advance(:months => 1), @now + 1.month
-#     assert_equal @dtnow.since(8), @dtnow + 8.seconds
-#     assert_equal @dtnow.since(22.9), @dtnow + 22.9.seconds
-#     assert_equal @dtnow.advance(:days => 15), @dtnow + 15.days
-#     assert_equal @dtnow.advance(:months => 1), @dtnow + 1.month
-#   end
-#
-#   def test_chaining_duration_operations
-#     assert_equal @now.advance(:days => 2).advance(:months => -3), @now + 2.days - 3.months
-#     assert_equal @now.advance(:days => 1).advance(:months => 2), @now + 1.day + 2.months
-#     assert_equal @dtnow.advance(:days => 2).advance(:months => -3), @dtnow + 2.days - 3.months
-#     assert_equal @dtnow.advance(:days => 1).advance(:months => 2), @dtnow + 1.day + 2.months
-#   end
-#
-#   def test_duration_after_convertion_is_no_longer_accurate
-#     assert_equal 30.days.to_i.since(@now), 1.month.to_i.since(@now)
-#     assert_equal 365.25.days.to_f.since(@now), 1.year.to_f.since(@now)
-#     assert_equal 30.days.to_i.since(@dtnow), 1.month.to_i.since(@dtnow)
-#     assert_equal 365.25.days.to_f.since(@dtnow), 1.year.to_f.since(@dtnow)
-#   end
-#
-#   def test_add_one_year_to_leap_day
-#     assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10) + 1.year
-#     assert_equal DateTime.civil(2005,2,28,15,15,10), DateTime.civil(2004,2,29,15,15,10) + 1.year
-#   end
-#
-#   def test_since_and_ago_anchored_to_time_now_when_time_zone_is_not_set
-#     Time.zone = nil
-#     with_env_tz 'US/Eastern' do
-#       Time.stubs(:now).returns Time.local(2000)
-#       # since
-#       assert_equal false, 5.since.is_a?(ActiveSupport::TimeWithZone)
-#       assert_equal Time.local(2000,1,1,0,0,5), 5.since
-#       # ago
-#       assert_equal false, 5.ago.is_a?(ActiveSupport::TimeWithZone)
-#       assert_equal Time.local(1999,12,31,23,59,55), 5.ago
-#     end
-#   end
-#
-#   def test_since_and_ago_anchored_to_time_zone_now_when_time_zone_is_set
-#     Time.zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
-#     with_env_tz 'US/Eastern' do
-#       Time.stubs(:now).returns Time.local(2000)
-#       # since
-#       assert_equal true, 5.since.is_a?(ActiveSupport::TimeWithZone)
-#       assert_equal Time.utc(2000,1,1,0,0,5), 5.since.time
-#       assert_equal 'Eastern Time (US & Canada)', 5.since.time_zone.name
-#       # ago
-#       assert_equal true, 5.ago.is_a?(ActiveSupport::TimeWithZone)
-#       assert_equal Time.utc(1999,12,31,23,59,55), 5.ago.time
-#       assert_equal 'Eastern Time (US & Canada)', 5.ago.time_zone.name
-#     end
-#   ensure
-#     Time.zone = nil
-#   end
-#
-#   protected
-#     def with_env_tz(new_tz = 'US/Eastern')
-#       old_tz, ENV['TZ'] = ENV['TZ'], new_tz
-#       yield
-#     ensure
-#       old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
-#     end
-# end
-#
 # class NumericExtDateTest < ActiveSupport::TestCase
 #   def setup
 #     @today = Date.today

data/test/core_ext/object_and_class_ext_test.rb

@@ -0,0 +1,183 @@
+require 'abstract_unit'
+require 'active_support/time'
+require 'active_support/core_ext/object'
+# require 'active_support/core_ext/class/subclasses'
+#
+# class ClassA; end
+# class ClassB < ClassA; end
+# class ClassC < ClassB; end
+# class ClassD < ClassA; end
+#
+# class ClassI; end
+# class ClassJ < ClassI; end
+#
+# class ClassK
+# end
+# module Nested
+#   class << self
+#     def on_const_missing(&callback)
+#       @on_const_missing = callback
+#     end
+#     private
+#       def const_missing(mod_id)
+#         @on_const_missing[mod_id] if @on_const_missing
+#         super
+#       end
+#   end
+#   class ClassL < ClassK
+#   end
+# end
+#
+# class ObjectTests < ActiveSupport::TestCase
+#   class DuckTime
+#     def acts_like_time?
+#       true
+#     end
+#   end
+#
+#   def test_duck_typing
+#     object = Object.new
+#     time   = Time.now
+#     date   = Date.today
+#     dt     = DateTime.new
+#     duck   = DuckTime.new
+#
+#     assert !object.acts_like?(:time)
+#     assert !object.acts_like?(:date)
+#
+#     assert time.acts_like?(:time)
+#     assert !time.acts_like?(:date)
+#
+#     assert !date.acts_like?(:time)
+#     assert date.acts_like?(:date)
+#
+#     assert dt.acts_like?(:time)
+#     assert dt.acts_like?(:date)
+#
+#     assert duck.acts_like?(:time)
+#     assert !duck.acts_like?(:date)
+#   end
+# end
+#
+# class ObjectInstanceVariableTest < ActiveSupport::TestCase
+#   def setup
+#     @source, @dest = Object.new, Object.new
+#     @source.instance_variable_set(:@bar, 'bar')
+#     @source.instance_variable_set(:@baz, 'baz')
+#   end
+#
+#   def test_instance_variable_names
+#     assert_equal %w(@bar @baz), @source.instance_variable_names.sort
+#   end
+#
+#   def test_instance_values
+#     object = Object.new
+#     object.instance_variable_set :@a, 1
+#     object.instance_variable_set :@b, 2
+#     assert_equal({'a' => 1, 'b' => 2}, object.instance_values)
+#   end
+#
+#   def test_instance_exec_passes_arguments_to_block
+#     assert_equal %w(hello goodbye), 'hello'.instance_exec('goodbye') { |v| [self, v] }
+#   end
+#
+#   def test_instance_exec_with_frozen_obj
+#     assert_equal %w(olleh goodbye), 'hello'.freeze.instance_exec('goodbye') { |v| [reverse, v] }
+#   end
+#
+#   def test_instance_exec_nested
+#     assert_equal %w(goodbye olleh bar), 'hello'.instance_exec('goodbye') { |arg|
+#       [arg] + instance_exec('bar') { |v| [reverse, v] } }
+#   end
+# end
+
+class ObjectTryTest < ActiveSupport::TestCase
+  def setup
+    @string = "Hello"
+  end
+
+  def test_nonexisting_method
+    method = :undefined_method
+    assert !@string.respond_to?(method)
+    assert_nil @string.try(method)
+  end
+
+  def test_nonexisting_method_with_arguments
+    method = :undefined_method
+    assert !@string.respond_to?(method)
+    assert_nil @string.try(method, 'llo', 'y')
+  end
+
+  def test_nonexisting_method_bang
+    method = :undefined_method
+    assert !@string.respond_to?(method)
+    assert_raise(NoMethodError) { @string.try!(method) }
+  end
+
+  def test_nonexisting_method_with_arguments_bang
+    method = :undefined_method
+    assert !@string.respond_to?(method)
+    assert_raise(NoMethodError) { @string.try!(method, 'llo', 'y') }
+  end
+
+  def test_try_only_block_bang
+    assert_equal @string.reverse, @string.try! { |s| s.reverse }
+  end
+
+  def test_valid_method
+    assert_equal 5, @string.try(:size)
+  end
+
+  def test_argument_forwarding
+    assert_equal 'Hey', @string.try(:sub, 'llo', 'y')
+  end
+
+  def test_block_forwarding
+    assert_equal 'Hey', @string.try(:sub, 'llo') { |match| 'y' }
+  end
+
+  def test_nil_to_type
+    assert_nil nil.try(:to_s)
+    assert_nil nil.try(:to_i)
+  end
+
+  def test_false_try
+    assert_equal 'false', false.try(:to_s)
+  end
+
+  def test_try_only_block
+    assert_equal @string.reverse, @string.try { |s| s.reverse }
+  end
+
+  def test_try_only_block_nil
+    ran = false
+    nil.try { ran = true }
+    assert_equal false, ran
+  end
+
+  # Opal doesn't support private methods
+  # def test_try_with_private_method_bang
+  #   klass = Class.new do
+  #     private
+  #
+  #     def private_method
+  #       'private method'
+  #     end
+  #   end
+  #
+  #   assert_raise(NoMethodError) { klass.new.try!(:private_method) }
+  # end
+
+  # Opal doesn't support private methods
+  # def test_try_with_private_method
+  #   klass = Class.new do
+  #     private
+  #
+  #     def private_method
+  #       'private method'
+  #     end
+  #   end
+  #
+  #   assert_nil klass.new.try(:private_method)
+  # end
+end

data/test/core_ext/string_ext_test.rb

@@ -0,0 +1,628 @@
+# encoding: utf-8
+require 'date'
+require 'abstract_unit'
+require 'inflector_test_cases'
+# require 'constantize_test_cases'
+
+require 'active_support/inflector'
+require 'active_support/core_ext/string'
+require 'active_support/time'
+# require 'active_support/core_ext/string/strip'
+# require 'active_support/core_ext/string/output_safety'
+# require 'active_support/core_ext/string/indent'
+
+module Ace
+  module Base
+    class Case
+    end
+  end
+end
+
+class StringInflectionsTest < ActiveSupport::TestCase
+  include InflectorTestCases
+  # include ConstantizeTestCases
+
+  # def test_strip_heredoc_on_an_empty_string
+  #   assert_equal '', ''.strip_heredoc
+  # end
+  #
+  # def test_strip_heredoc_on_a_string_with_no_lines
+  #   assert_equal 'x', 'x'.strip_heredoc
+  #   assert_equal 'x', '    x'.strip_heredoc
+  # end
+  #
+  # def test_strip_heredoc_on_a_heredoc_with_no_margin
+  #   assert_equal "foo\nbar", "foo\nbar".strip_heredoc
+  #   assert_equal "foo\n  bar", "foo\n  bar".strip_heredoc
+  # end
+  #
+  # def test_strip_heredoc_on_a_regular_indented_heredoc
+  #   assert_equal "foo\n  bar\nbaz\n", <<-EOS.strip_heredoc
+  #     foo
+  #       bar
+  #     baz
+  #   EOS
+  # end
+  #
+  # def test_strip_heredoc_on_a_regular_indented_heredoc_with_blank_lines
+  #   assert_equal "foo\n  bar\n\nbaz\n", <<-EOS.strip_heredoc
+  #     foo
+  #       bar
+  #
+  #     baz
+  #   EOS
+  # end
+  #
+  # def test_pluralize
+  #   SingularToPlural.each do |singular, plural|
+  #     assert_equal(plural, singular.pluralize)
+  #   end
+  #
+  #   assert_equal("plurals", "plurals".pluralize)
+  #
+  #   assert_equal("blargles", "blargle".pluralize(0))
+  #   assert_equal("blargle", "blargle".pluralize(1))
+  #   assert_equal("blargles", "blargle".pluralize(2))
+  # end
+  #
+  # def test_singularize
+  #   SingularToPlural.each do |singular, plural|
+  #     assert_equal(singular, plural.singularize)
+  #   end
+  # end
+  #
+  # def test_titleize
+  #   MixtureToTitleCase.each do |before, titleized|
+  #     assert_equal(titleized, before.titleize)
+  #   end
+  # end
+
+  def test_camelize
+    CamelToUnderscore.each do |camel, underscore|
+      assert_equal(camel, underscore.camelize)
+    end
+  end
+
+  def test_camelize_lower
+    assert_equal('capital', 'Capital'.camelize(:lower))
+  end
+
+  def test_dasherize
+    UnderscoresToDashes.each do |underscored, dasherized|
+      assert_equal(dasherized, underscored.dasherize)
+    end
+  end
+
+  def test_underscore
+    CamelToUnderscore.each do |camel, underscore|
+      assert_equal(underscore, camel.underscore)
+    end
+
+    assert_equal "html_tidy", "HTMLTidy".underscore
+    assert_equal "html_tidy_generator", "HTMLTidyGenerator".underscore
+  end
+
+  def test_underscore_to_lower_camel
+    UnderscoreToLowerCamel.each do |underscored, lower_camel|
+      assert_equal(lower_camel, underscored.camelize(:lower))
+    end
+  end
+
+  def test_demodulize
+    assert_equal "Account", "MyApplication::Billing::Account".demodulize
+  end
+
+  # def test_deconstantize
+  #   assert_equal "MyApplication::Billing", "MyApplication::Billing::Account".deconstantize
+  # end
+  #
+  # def test_foreign_key
+  #   ClassNameToForeignKeyWithUnderscore.each do |klass, foreign_key|
+  #     assert_equal(foreign_key, klass.foreign_key)
+  #   end
+  #
+  #   ClassNameToForeignKeyWithoutUnderscore.each do |klass, foreign_key|
+  #     assert_equal(foreign_key, klass.foreign_key(false))
+  #   end
+  # end
+  #
+  # def test_tableize
+  #   ClassNameToTableName.each do |class_name, table_name|
+  #     assert_equal(table_name, class_name.tableize)
+  #   end
+  # end
+  #
+  # def test_classify
+  #   ClassNameToTableName.each do |class_name, table_name|
+  #     assert_equal(class_name, table_name.classify)
+  #   end
+  # end
+  #
+  # def test_string_parameterized_normal
+  #   StringToParameterized.each do |normal, slugged|
+  #     assert_equal(normal.parameterize, slugged)
+  #   end
+  # end
+  #
+  # def test_string_parameterized_no_separator
+  #   StringToParameterizeWithNoSeparator.each do |normal, slugged|
+  #     assert_equal(normal.parameterize(''), slugged)
+  #   end
+  # end
+  #
+  # def test_string_parameterized_underscore
+  #   StringToParameterizeWithUnderscore.each do |normal, slugged|
+  #     assert_equal(normal.parameterize('_'), slugged)
+  #   end
+  # end
+  #
+  # def test_humanize
+  #   UnderscoreToHuman.each do |underscore, human|
+  #     assert_equal(human, underscore.humanize)
+  #   end
+  # end
+  #
+  # def test_ord
+  #   assert_equal 97, 'a'.ord
+  #   assert_equal 97, 'abc'.ord
+  # end
+  #
+  # def test_access
+  #   s = "hello"
+  #   assert_equal "h", s.at(0)
+  #
+  #   assert_equal "llo", s.from(2)
+  #   assert_equal "hel", s.to(2)
+  #
+  #   assert_equal "h", s.first
+  #   assert_equal "he", s.first(2)
+  #   assert_equal "", s.first(0)
+  #
+  #   assert_equal "o", s.last
+  #   assert_equal "llo", s.last(3)
+  #   assert_equal "hello", s.last(10)
+  #   assert_equal "", s.last(0)
+  #
+  #   assert_equal 'x', 'x'.first
+  #   assert_equal 'x', 'x'.first(4)
+  #
+  #   assert_equal 'x', 'x'.last
+  #   assert_equal 'x', 'x'.last(4)
+  # end
+  #
+  # def test_access_returns_a_real_string
+  #   hash = {}
+  #   hash["h"] = true
+  #   hash["hello123".at(0)] = true
+  #   assert_equal %w(h), hash.keys
+  #
+  #   hash = {}
+  #   hash["llo"] = true
+  #   hash["hello".from(2)] = true
+  #   assert_equal %w(llo), hash.keys
+  #
+  #   hash = {}
+  #   hash["hel"] = true
+  #   hash["hello".to(2)] = true
+  #   assert_equal %w(hel), hash.keys
+  #
+  #   hash = {}
+  #   hash["hello"] = true
+  #   hash["123hello".last(5)] = true
+  #   assert_equal %w(hello), hash.keys
+  #
+  #   hash = {}
+  #   hash["hello"] = true
+  #   hash["hello123".first(5)] = true
+  #   assert_equal %w(hello), hash.keys
+  # end
+  #
+  # def test_starts_ends_with_alias
+  #   s = "hello"
+  #   assert s.starts_with?('h')
+  #   assert s.starts_with?('hel')
+  #   assert !s.starts_with?('el')
+  #
+  #   assert s.ends_with?('o')
+  #   assert s.ends_with?('lo')
+  #   assert !s.ends_with?('el')
+  # end
+  #
+  # def test_string_squish
+  #   original = %{\u180E\u180E A string surrounded by unicode mongolian vowel separators,
+  #     with tabs(\t\t), newlines(\n\n), unicode nextlines(\u0085\u0085) and many spaces(  ). \u180E\u180E}
+  #
+  #   expected = "A string surrounded by unicode mongolian vowel separators, " +
+  #     "with tabs( ), newlines( ), unicode nextlines( ) and many spaces( )."
+  #
+  #   # Make sure squish returns what we expect:
+  #   assert_equal original.squish,  expected
+  #   # But doesn't modify the original string:
+  #   assert_not_equal original, expected
+  #
+  #   # Make sure squish! returns what we expect:
+  #   assert_equal original.squish!, expected
+  #   # And changes the original string:
+  #   assert_equal original, expected
+  # end
+  #
+  # def test_string_inquiry
+  #   assert "production".inquiry.production?
+  #   assert !"production".inquiry.development?
+  # end
+  #
+  # def test_truncate
+  #   assert_equal "Hello World!", "Hello World!".truncate(12)
+  #   assert_equal "Hello Wor...", "Hello World!!".truncate(12)
+  # end
+  #
+  # def test_truncate_with_omission_and_seperator
+  #   assert_equal "Hello[...]", "Hello World!".truncate(10, :omission => "[...]")
+  #   assert_equal "Hello[...]", "Hello Big World!".truncate(13, :omission => "[...]", :separator => ' ')
+  #   assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, :omission => "[...]", :separator => ' ')
+  #   assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, :omission => "[...]", :separator => ' ')
+  # end
+  #
+  # def test_truncate_with_omission_and_regexp_seperator
+  #   assert_equal "Hello[...]", "Hello Big World!".truncate(13, :omission => "[...]", :separator => /\s/)
+  #   assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, :omission => "[...]", :separator => /\s/)
+  #   assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, :omission => "[...]", :separator => /\s/)
+  # end
+  #
+  # def test_truncate_multibyte
+  #   assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding(Encoding::UTF_8),
+  #     "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding(Encoding::UTF_8).truncate(10)
+  # end
+  #
+  # def test_truncate_should_not_be_html_safe
+  #   assert !"Hello World!".truncate(12).html_safe?
+  # end
+  #
+  # def test_constantize
+  #   run_constantize_tests_on do |string|
+  #     string.constantize
+  #   end
+  # end
+  #
+  # def test_safe_constantize
+  #   run_safe_constantize_tests_on do |string|
+  #     string.safe_constantize
+  #   end
+  # end
+end
+
+# class StringConversionsTest < ActiveSupport::TestCase
+#   def test_string_to_time
+#     with_env_tz "Europe/Moscow" do
+#       assert_equal Time.utc(2005, 2, 27, 23, 50), "2005-02-27 23:50".to_time(:utc)
+#       assert_equal Time.local(2005, 2, 27, 23, 50), "2005-02-27 23:50".to_time
+#       assert_equal Time.utc(2005, 2, 27, 23, 50, 19, 275038), "2005-02-27T23:50:19.275038".to_time(:utc)
+#       assert_equal Time.local(2005, 2, 27, 23, 50, 19, 275038), "2005-02-27T23:50:19.275038".to_time
+#       assert_equal Time.utc(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_time(:utc)
+#       assert_equal Time.local(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_time
+#       assert_equal Time.local(2011, 2, 27, 18, 50), "2011-02-27 13:50 -0100".to_time
+#       assert_equal Time.utc(2011, 2, 27, 23, 50), "2011-02-27 22:50 -0100".to_time(:utc)
+#       assert_equal Time.local(2005, 2, 27, 23, 50), "2005-02-27 14:50 -0500".to_time
+#       assert_nil "".to_time
+#     end
+#   end
+#
+#   def test_string_to_time_utc_offset
+#     with_env_tz "US/Eastern" do
+#       assert_equal 0, "2005-02-27 23:50".to_time(:utc).utc_offset
+#       assert_equal(-18000, "2005-02-27 23:50".to_time.utc_offset)
+#       assert_equal 0, "2005-02-27 22:50 -0100".to_time(:utc).utc_offset
+#       assert_equal(-18000, "2005-02-27 22:50 -0100".to_time.utc_offset)
+#     end
+#   end
+#
+#   def test_partial_string_to_time
+#     with_env_tz "Europe/Moscow" do
+#       now = Time.now
+#       assert_equal Time.local(now.year, now.month, now.day, 23, 50), "23:50".to_time
+#       assert_equal Time.utc(now.year, now.month, now.day, 23, 50), "23:50".to_time(:utc)
+#       assert_equal Time.local(now.year, now.month, now.day, 18, 50), "13:50 -0100".to_time
+#       assert_equal Time.utc(now.year, now.month, now.day, 23, 50), "22:50 -0100".to_time(:utc)
+#     end
+#   end
+#
+#   def test_string_to_datetime
+#     assert_equal DateTime.civil(2039, 2, 27, 23, 50), "2039-02-27 23:50".to_datetime
+#     assert_equal 0, "2039-02-27 23:50".to_datetime.offset # use UTC offset
+#     assert_equal ::Date::ITALY, "2039-02-27 23:50".to_datetime.start # use Ruby's default start value
+#     assert_equal DateTime.civil(2039, 2, 27, 23, 50, 19 + Rational(275038, 1000000), "-04:00"), "2039-02-27T23:50:19.275038-04:00".to_datetime
+#     assert_nil "".to_datetime
+#   end
+#
+#   def test_partial_string_to_datetime
+#     now = DateTime.now
+#     assert_equal DateTime.civil(now.year, now.month, now.day, 23, 50), "23:50".to_datetime
+#     assert_equal DateTime.civil(now.year, now.month, now.day, 23, 50, 0, "-04:00"), "23:50 -0400".to_datetime
+#   end
+#
+#   def test_string_to_date
+#     assert_equal Date.new(2005, 2, 27), "2005-02-27".to_date
+#     assert_nil "".to_date
+#     assert_equal Date.new(Date.today.year, 2, 3), "Feb 3rd".to_date
+#   end
+#
+#   protected
+#     def with_env_tz(new_tz = 'US/Eastern')
+#       old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+#       yield
+#     ensure
+#       old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+#     end
+# end
+#
+# class StringBehaviourTest < ActiveSupport::TestCase
+#   def test_acts_like_string
+#     assert 'Bambi'.acts_like_string?
+#   end
+# end
+#
+# class CoreExtStringMultibyteTest < ActiveSupport::TestCase
+#   UTF8_STRING = 'こにちわ'
+#   ASCII_STRING = 'ohayo'.encode('US-ASCII')
+#   EUC_JP_STRING = 'さよなら'.encode('EUC-JP')
+#   INVALID_UTF8_STRING = "\270\236\010\210\245"
+#
+#   def test_core_ext_adds_mb_chars
+#     assert_respond_to UTF8_STRING, :mb_chars
+#   end
+#
+#   def test_string_should_recognize_utf8_strings
+#     assert UTF8_STRING.is_utf8?
+#     assert ASCII_STRING.is_utf8?
+#     assert !EUC_JP_STRING.is_utf8?
+#     assert !INVALID_UTF8_STRING.is_utf8?
+#   end
+#
+#   def test_mb_chars_returns_instance_of_proxy_class
+#     assert_kind_of ActiveSupport::Multibyte.proxy_class, UTF8_STRING.mb_chars
+#   end
+# end
+#
+# class OutputSafetyTest < ActiveSupport::TestCase
+#   def setup
+#     @string = "hello"
+#     @object = Class.new(Object) do
+#       def to_s
+#         "other"
+#       end
+#     end.new
+#   end
+#
+#   test "A string is unsafe by default" do
+#     assert !@string.html_safe?
+#   end
+#
+#   test "A string can be marked safe" do
+#     string = @string.html_safe
+#     assert string.html_safe?
+#   end
+#
+#   test "Marking a string safe returns the string" do
+#     assert_equal @string, @string.html_safe
+#   end
+#
+#   test "A fixnum is safe by default" do
+#     assert 5.html_safe?
+#   end
+#
+#   test "a float is safe by default" do
+#     assert 5.7.html_safe?
+#   end
+#
+#   test "An object is unsafe by default" do
+#     assert !@object.html_safe?
+#   end
+#
+#   test "Adding an object to a safe string returns a safe string" do
+#     string = @string.html_safe
+#     string << @object
+#
+#     assert_equal "helloother", string
+#     assert string.html_safe?
+#   end
+#
+#   test "Adding a safe string to another safe string returns a safe string" do
+#     @other_string = "other".html_safe
+#     string = @string.html_safe
+#     @combination = @other_string + string
+#
+#     assert_equal "otherhello", @combination
+#     assert @combination.html_safe?
+#   end
+#
+#   test "Adding an unsafe string to a safe string escapes it and returns a safe string" do
+#     @other_string = "other".html_safe
+#     @combination = @other_string + "<foo>"
+#     @other_combination = @string + "<foo>"
+#
+#     assert_equal "other&lt;foo&gt;", @combination
+#     assert_equal "hello<foo>", @other_combination
+#
+#     assert @combination.html_safe?
+#     assert !@other_combination.html_safe?
+#   end
+#
+#   test "Concatting safe onto unsafe yields unsafe" do
+#     @other_string = "other"
+#
+#     string = @string.html_safe
+#     @other_string.concat(string)
+#     assert !@other_string.html_safe?
+#   end
+#
+#   test "Concatting unsafe onto safe yields escaped safe" do
+#     @other_string = "other".html_safe
+#     string = @other_string.concat("<foo>")
+#     assert_equal "other&lt;foo&gt;", string
+#     assert string.html_safe?
+#   end
+#
+#   test "Concatting safe onto safe yields safe" do
+#     @other_string = "other".html_safe
+#     string = @string.html_safe
+#
+#     @other_string.concat(string)
+#     assert @other_string.html_safe?
+#   end
+#
+#   test "Concatting safe onto unsafe with << yields unsafe" do
+#     @other_string = "other"
+#     string = @string.html_safe
+#
+#     @other_string << string
+#     assert !@other_string.html_safe?
+#   end
+#
+#   test "Concatting unsafe onto safe with << yields escaped safe" do
+#     @other_string = "other".html_safe
+#     string = @other_string << "<foo>"
+#     assert_equal "other&lt;foo&gt;", string
+#     assert string.html_safe?
+#   end
+#
+#   test "Concatting safe onto safe with << yields safe" do
+#     @other_string = "other".html_safe
+#     string = @string.html_safe
+#
+#     @other_string << string
+#     assert @other_string.html_safe?
+#   end
+#
+#   test "Concatting safe onto unsafe with % yields unsafe" do
+#     @other_string = "other%s"
+#     string = @string.html_safe
+#
+#     @other_string = @other_string % string
+#     assert !@other_string.html_safe?
+#   end
+#
+#   test "Concatting unsafe onto safe with % yields escaped safe" do
+#     @other_string = "other%s".html_safe
+#     string = @other_string % "<foo>"
+#
+#     assert_equal "other&lt;foo&gt;", string
+#     assert string.html_safe?
+#   end
+#
+#   test "Concatting safe onto safe with % yields safe" do
+#     @other_string = "other%s".html_safe
+#     string = @string.html_safe
+#
+#     @other_string = @other_string % string
+#     assert @other_string.html_safe?
+#   end
+#
+#   test "Concatting with % doesn't modify a string" do
+#     @other_string = ["<p>", "<b>", "<h1>"]
+#     _ = "%s %s %s".html_safe % @other_string
+#
+#     assert_equal ["<p>", "<b>", "<h1>"], @other_string
+#   end
+#
+#   test "Concatting a fixnum to safe always yields safe" do
+#     string = @string.html_safe
+#     string = string.concat(13)
+#     assert_equal "hello".concat(13), string
+#     assert string.html_safe?
+#   end
+#
+#   test 'emits normal string yaml' do
+#     assert_equal 'foo'.to_yaml, 'foo'.html_safe.to_yaml(:foo => 1)
+#   end
+#
+#   test 'knows whether it is encoding aware' do
+#     assert_deprecated do
+#       assert 'ruby'.encoding_aware?
+#     end
+#   end
+#
+#   test "call to_param returns a normal string" do
+#     string = @string.html_safe
+#     assert string.html_safe?
+#     assert !string.to_param.html_safe?
+#   end
+#
+#   test "ERB::Util.html_escape should escape unsafe characters" do
+#     string = '<>&"\''
+#     expected = '&lt;&gt;&amp;&quot;&#39;'
+#     assert_equal expected, ERB::Util.html_escape(string)
+#   end
+#
+#   test "ERB::Util.html_escape should correctly handle invalid UTF-8 strings" do
+#     string = [192, 60].pack('CC')
+#     expected = 192.chr + "&lt;"
+#     assert_equal expected, ERB::Util.html_escape(string)
+#   end
+#
+#   test "ERB::Util.html_escape should not escape safe strings" do
+#     string = "<b>hello</b>".html_safe
+#     assert_equal string, ERB::Util.html_escape(string)
+#   end
+# end
+#
+# class StringExcludeTest < ActiveSupport::TestCase
+#   test 'inverse of #include' do
+#     assert_equal false, 'foo'.exclude?('o')
+#     assert_equal true, 'foo'.exclude?('p')
+#   end
+# end
+#
+# class StringIndentTest < ActiveSupport::TestCase
+#   test 'does not indent strings that only contain newlines (edge cases)' do
+#     ['', "\n", "\n" * 7].each do |str|
+#       assert_nil str.indent!(8)
+#       assert_equal str, str.indent(8)
+#       assert_equal str, str.indent(1, "\t")
+#     end
+#   end
+#
+#   test "by default, indents with spaces if the existing indentation uses them" do
+#     assert_equal "    foo\n      bar", "foo\n  bar".indent(4)
+#   end
+#
+#   test "by default, indents with tabs if the existing indentation uses them" do
+#     assert_equal "\tfoo\n\t\t\bar", "foo\n\t\bar".indent(1)
+#   end
+#
+#   test "by default, indents with spaces as a fallback if there is no indentation" do
+#     assert_equal "   foo\n   bar\n   baz", "foo\nbar\nbaz".indent(3)
+#   end
+#
+#   # Nothing is said about existing indentation that mixes spaces and tabs, so
+#   # there is nothing to test.
+#
+#   test 'uses the indent char if passed' do
+#     assert_equal <<EXPECTED, <<ACTUAL.indent(4, '.')
+# ....  def some_method(x, y)
+# ....    some_code
+# ....  end
+# EXPECTED
+#   def some_method(x, y)
+#     some_code
+#   end
+# ACTUAL
+#
+#     assert_equal <<EXPECTED, <<ACTUAL.indent(2, '&nbsp;')
+# &nbsp;&nbsp;&nbsp;&nbsp;def some_method(x, y)
+# &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;some_code
+# &nbsp;&nbsp;&nbsp;&nbsp;end
+# EXPECTED
+# &nbsp;&nbsp;def some_method(x, y)
+# &nbsp;&nbsp;&nbsp;&nbsp;some_code
+# &nbsp;&nbsp;end
+# ACTUAL
+#   end
+#
+#   test "does not indent blank lines by default" do
+#     assert_equal " foo\n\n bar", "foo\n\nbar".indent(1)
+#   end
+#
+#   test 'indents blank lines if told so' do
+#     assert_equal " foo\n \n bar", "foo\n\nbar".indent(1, nil, true)
+#   end
+# end