Class Object < BasicObject

# File activejob/test/support/backburner/inline.rb, line 5
def self.enqueue(job_class, args=[], opts={})
  job_class.perform(*args)
end

# File activesupport/lib/active_support/core_ext/object/acts_like.rb, line 7
def acts_like?(duck)
  respond_to? :"acts_like_#{duck}?"
end

# File activemodel/test/cases/attribute_methods_test.rb, line 87
def attribute(name)
  attributes[name.to_sym]
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 15
def blank?
  respond_to?(:empty?) ? !!empty? : !self
end

# File guides/rails_guides.rb, line 5
def bundler?
  # Note that rake sets the cwd to the one that contains the Rakefile
  # being executed.
  File.exist?('Gemfile')
end

# File railties/lib/rails/test_help.rb, line 28
def create_fixtures(*fixture_set_names, &block)
  FixtureSet.create_fixtures(ActiveSupport::TestCase.fixture_path, fixture_set_names, {}, &block)
end

# File activerecord/test/cases/helper.rb, line 36
def current_adapter?(*types)
  types.any? do |type|
    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
  end
end

# File activesupport/lib/active_support/core_ext/object/deep_dup.rb, line 13
def deep_dup
  duplicable? ? dup : self
end

# File activerecord/test/cases/helper.rb, line 132
def disable_extension!(extension, connection)
  return false unless connection.supports_extensions?
  return true unless connection.extension_enabled?(extension)

  connection.disable_extension extension
  connection.reconnect!
end

# File activesupport/lib/active_support/core_ext/object/duplicable.rb, line 24
def duplicable?
  true
end

# File activerecord/test/cases/helper.rb, line 123
def enable_extension!(extension, connection)
  return false unless connection.supports_extensions?
  return connection.reconnect! if connection.extension_enabled?(extension)

  connection.enable_extension extension
  connection.commit_db_transaction
  connection.reconnect!
end

# File activerecord/test/schema/schema.rb, line 3
def except(adapter_names_to_exclude)
  unless [adapter_names_to_exclude].flatten.include?(adapter_name)
    yield
  end
end

# File activesupport/lib/active_support/core_ext/string/output_safety.rb, line 120
def html_safe?
  false
end

# File activesupport/lib/active_support/core_ext/object/inclusion.rb, line 10
def in?(another_object)
  another_object.include?(self)
rescue NoMethodError
  raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
end

# File activerecord/test/cases/helper.rb, line 43
def in_memory_db?
  current_adapter?(:SQLite3Adapter) &&
  ActiveRecord::Base.connection_pool.spec.config[:database] == ":memory:"
end

# File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 12
def instance_values
  Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
end

# File activesupport/lib/active_support/core_ext/object/instance_variables.rb, line 25
def instance_variable_names
  instance_variables.map { |var| var.to_s }
end

# File activesupport/lib/active_support/core_ext/object/itself.rb, line 11
def itself
  self
end

# File actionmailer/test/abstract_unit.rb, line 40
def jruby_skip(message = '')
  skip message if defined?(JRUBY_VERSION)
end

# File activerecord/test/cases/helper.rb, line 154
def load_schema
  # silence verbose schema loading
  original_stdout = $stdout
  $stdout = StringIO.new

  adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
  adapter_specific_schema_file = SCHEMA_ROOT + "/#{adapter_name}_specific_schema.rb"

  load SCHEMA_ROOT + "/schema.rb"

  if File.exist?(adapter_specific_schema_file)
    load adapter_specific_schema_file
  end
ensure
  $stdout = original_stdout
end

# File activerecord/test/cases/helper.rb, line 48
def mysql_56?
  current_adapter?(:MysqlAdapter, :Mysql2Adapter) &&
    ActiveRecord::Base.connection.send(:version) >= '5.6.0' &&
    ActiveRecord::Base.connection.send(:version) < '5.7.0'
end

# File activerecord/test/cases/helper.rb, line 54
def mysql_enforcing_gtid_consistency?
  current_adapter?(:MysqlAdapter, :Mysql2Adapter) && 'ON' == ActiveRecord::Base.connection.show_variable('enforce_gtid_consistency')
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 42
def presence
  self if present?
end

# File activesupport/lib/active_support/core_ext/object/inclusion.rb, line 24
def presence_in(another_object)
  self.in?(another_object) ? self : nil
end

# File activesupport/lib/active_support/core_ext/object/blank.rb, line 22
def present?
  !blank?
end

# File activerecord/examples/performance.rb, line 46
def progress_bar(int); print "." if (int%100).zero? ; end

# File actionmailer/test/abstract_unit.rb, line 36
def rubinius_skip(message = '')
  skip message if RUBY_ENGINE == 'rbx'
end

# File activejob/test/helper.rb, line 14
def ruby_193?
  RUBY_VERSION == '1.9.3' && RUBY_ENGINE != 'java'
end

# File activejob/test/helper.rb, line 10
def sidekiq?
  @adapter == 'sidekiq'
end

# File activerecord/test/cases/helper.rb, line 58
def supports_savepoints?
  ActiveRecord::Base.connection.supports_savepoints?
end

# File activerecord/test/cases/inheritance_test.rb, line 97
def test_a_bad_type_column
  Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"

  assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
end

# File activerecord/test/cases/inheritance_test.rb, line 85
def test_abstract_inheritance_base_class
  assert_equal LoosePerson, LoosePerson.base_class
  assert_equal LooseDescendant, LooseDescendant.base_class
  assert_equal TightPerson, TightPerson.base_class
  assert_equal TightPerson, TightDescendant.base_class
end

# File activerecord/test/cases/inheritance_test.rb, line 130
def test_alt_becomes_bang_resets_inheritance_type_column
  vegetable = Vegetable.create!(name: "Red Pepper")
  assert_nil vegetable.custom_type

  cabbage = vegetable.becomes!(Cabbage)
  assert_equal "Cabbage", cabbage.custom_type

  vegetable = cabbage.becomes!(Vegetable)
  assert_nil cabbage.custom_type
end

# File activerecord/test/cases/inheritance_test.rb, line 117
def test_alt_becomes_works_with_sti
  vegetable = Vegetable.find(1)
  assert_kind_of Vegetable, vegetable
  cabbage = vegetable.becomes(Cabbage)
  assert_kind_of Cabbage, cabbage
end

# File activerecord/test/cases/inheritance_test.rb, line 291
def test_alt_complex_inheritance
  king_cole = KingCole.create("name" => "uniform heads")
  assert_equal king_cole, KingCole.where("name = 'uniform heads'").first
  assert_equal king_cole, GreenCabbage.all.merge!(:where => "name = 'uniform heads'").first
  assert_equal king_cole, Cabbage.all.merge!(:where => "name = 'uniform heads'").first
  assert_equal king_cole, Vegetable.all.merge!(:where => "name = 'uniform heads'").first
  assert_equal 1, Cabbage.all.merge!(:where => "name = 'his cabbage'").to_a.size
  assert_equal king_cole, Cabbage.find(king_cole.id)
end

# File activerecord/test/cases/inheritance_test.rb, line 263
def test_alt_destroy_all_within_inheritance
  Cabbage.destroy_all
  assert_equal 0, Cabbage.count
  assert_equal 1, Cucumber.count
end

# File activerecord/test/cases/inheritance_test.rb, line 306
def test_alt_eager_loading
  cabbage = RedCabbage.all.merge!(:includes => :seller).find(4)
  assert cabbage.association(:seller).loaded?, "association was not eager loaded"
end

# File activerecord/test/cases/inheritance_test.rb, line 275
def test_alt_find_first_within_inheritance
  assert_kind_of Cabbage, Vegetable.all.merge!(:where => "name = 'his cabbage'").first
  assert_kind_of Cabbage, Cabbage.all.merge!(:where => "name = 'his cabbage'").first
  assert_nil Cucumber.all.merge!(:where => "name = 'his cabbage'").first
end

# File activerecord/test/cases/inheritance_test.rb, line 239
def test_alt_finding_incorrect_type_data
  assert_raise(ActiveRecord::RecordNotFound) { Cucumber.find(2) }
  assert_nothing_raised   { Cucumber.find(1) }
end

# File activerecord/test/cases/inheritance_test.rb, line 228
def test_alt_inheritance_condition
  assert_equal 4, Vegetable.count
  assert_equal 1, Cucumber.count
  assert_equal 3, Cabbage.count
end

# File activerecord/test/cases/inheritance_test.rb, line 110
def test_alt_inheritance_find
  assert_kind_of Cucumber, Vegetable.find(1)
  assert_kind_of Cucumber, Cucumber.find(1)
  assert_kind_of Cabbage, Vegetable.find(2)
  assert_kind_of Cabbage, Cabbage.find(2)
end

# File activerecord/test/cases/inheritance_test.rb, line 147
def test_alt_inheritance_find_all
  companies = Vegetable.all.merge!(:order => 'id').to_a
  assert_kind_of Cucumber, companies[0]
  assert_kind_of Cabbage, companies[1]
end

# File activerecord/test/cases/inheritance_test.rb, line 162
def test_alt_inheritance_save
  cabbage = Cabbage.new(:name => 'Savoy')
  cabbage.save!

  savoy = Vegetable.find(cabbage.id)
  assert_kind_of Cabbage, savoy
end

# File activerecord/test/cases/inheritance_test.rb, line 251
def test_alt_update_all_within_inheritance
  Cabbage.update_all "name = 'the cabbage'"
  assert_equal "the cabbage", Cabbage.first.name
  assert_equal ["my cucumber"], Cucumber.all.map(&:name).uniq
end

# File activerecord/test/cases/inheritance_test.rb, line 92
def test_base_class_activerecord_error
  klass = Class.new { include ActiveRecord::Inheritance }
  assert_raise(ActiveRecord::ActiveRecordError) { klass.base_class }
end

# File activerecord/test/cases/inheritance_test.rb, line 124
def test_becomes_and_change_tracking_for_inheritance_columns
  cucumber = Vegetable.find(1)
  cabbage = cucumber.becomes!(Cabbage)
  assert_equal ['Cucumber', 'Cabbage'], cabbage.custom_type_change
end

# File activerecord/test/cases/inheritance_test.rb, line 35
def test_class_without_store_full_sti_class_returns_demodulized_name
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = false
  assert_equal 'Company', Namespaced::Company.sti_name
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 71
def test_company_descends_from_active_record
  assert !ActiveRecord::Base.descends_from_active_record?
  assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'
  assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base'
  assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base'
end

# File activerecord/test/cases/inheritance_test.rb, line 281
def test_complex_inheritance
  very_special_client = VerySpecialClient.create("name" => "veryspecial")
  assert_equal very_special_client, VerySpecialClient.where("name = 'veryspecial'").first
  assert_equal very_special_client, SpecialClient.all.merge!(:where => "name = 'veryspecial'").first
  assert_equal very_special_client, Company.all.merge!(:where => "name = 'veryspecial'").first
  assert_equal very_special_client, Client.all.merge!(:where => "name = 'veryspecial'").first
  assert_equal 1, Client.all.merge!(:where => "name = 'Summit'").to_a.size
  assert_equal very_special_client, Client.find(very_special_client.id)
end

# File activerecord/test/cases/inheritance_test.rb, line 257
def test_destroy_all_within_inheritance
  Client.destroy_all
  assert_equal 0, Client.count
  assert_equal 2, Firm.count
end

# File activerecord/test/cases/inheritance_test.rb, line 61
def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_class_option
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = true
  item = Namespaced::Company.create :name => "Wolverine 2"
  assert_not_nil Company.find(item.id)
  assert_not_nil Namespaced::Company.find(item.id)
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 311
def test_eager_load_belongs_to_primary_key_quoting
  con = Account.connection
  assert_sql(/#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} IN \(1\)/) do
    Account.all.merge!(:includes => :firm).find(1)
  end
end

# File activerecord/test/cases/inheritance_test.rb, line 301
def test_eager_load_belongs_to_something_inherited
  account = Account.all.merge!(:includes => :firm).find(1)
  assert account.association(:firm).loaded?, "association was not eager loaded"
end

# File activerecord/test/cases/inheritance_test.rb, line 269
def test_find_first_within_inheritance
  assert_kind_of Firm, Company.all.merge!(:where => "name = '37signals'").first
  assert_kind_of Firm, Firm.all.merge!(:where => "name = '37signals'").first
  assert_nil Client.all.merge!(:where => "name = '37signals'").first
end

# File activerecord/test/cases/inheritance_test.rb, line 234
def test_finding_incorrect_type_data
  assert_raise(ActiveRecord::RecordNotFound) { Firm.find(2) }
  assert_nothing_raised   { Firm.find(1) }
end

# File activerecord/test/cases/inheritance_test.rb, line 78
def test_inheritance_base_class
  assert_equal Post, Post.base_class
  assert_equal Post, SpecialPost.base_class
  assert_equal Post, StiPost.base_class
  assert_equal SubStiPost, SubStiPost.base_class
end

# File activerecord/test/cases/inheritance_test.rb, line 222
def test_inheritance_condition
  assert_equal 11, Company.count
  assert_equal 2, Firm.count
  assert_equal 5, Client.count
end

# File activerecord/test/cases/inheritance_test.rb, line 103
def test_inheritance_find
  assert_kind_of Firm, Company.find(1), "37signals should be a firm"
  assert_kind_of Firm, Firm.find(1), "37signals should be a firm"
  assert_kind_of Client, Company.find(2), "Summit should be a client"
  assert_kind_of Client, Client.find(2), "Summit should be a client"
end

# File activerecord/test/cases/inheritance_test.rb, line 141
def test_inheritance_find_all
  companies = Company.all.merge!(:order => 'id').to_a
  assert_kind_of Firm, companies[0], "37signals should be a firm"
  assert_kind_of Client, companies[1], "Summit should be a client"
end

# File activerecord/test/cases/inheritance_test.rb, line 175
def test_inheritance_new_with_base_class
  company = Company.new(:type => 'Company')
  assert_equal Company, company.class
end

# File activerecord/test/cases/inheritance_test.rb, line 170
def test_inheritance_new_with_default_class
  company = Company.new
  assert_equal Company, company.class
end

# File activerecord/test/cases/inheritance_test.rb, line 180
def test_inheritance_new_with_subclass
  firm = Company.new(:type => 'Firm')
  assert_equal Firm, firm.class
end

# File activerecord/test/cases/inheritance_test.rb, line 153
def test_inheritance_save
  firm = Firm.new
  firm.name = "Next Angle"
  firm.save

  next_angle = Company.find(firm.id)
  assert_kind_of Firm, next_angle, "Next Angle should be a firm"
end

# File activerecord/test/cases/inheritance_test.rb, line 322
def test_inheritance_without_mapping
  assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
  assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
end

# File activerecord/test/cases/inheritance_test.rb, line 318
def test_inherits_custom_primary_key
  assert_equal Subscriber.primary_key, SpecialSubscriber.primary_key
end

# File activerecord/test/cases/inheritance_test.rb, line 185
def test_new_with_abstract_class
  e = assert_raises(NotImplementedError) do
    AbstractCompany.new
  end
  assert_equal("AbstractCompany is an abstract class and cannot be instantiated.", e.message)
end

# File activerecord/test/cases/inheritance_test.rb, line 192
def test_new_with_ar_base
  e = assert_raises(NotImplementedError) do
    ActiveRecord::Base.new
  end
  assert_equal("ActiveRecord::Base is an abstract class and cannot be instantiated.", e.message)
end

# File activerecord/test/cases/inheritance_test.rb, line 211
def test_new_with_autoload_paths
  path = File.expand_path('../../models/autoloadable', __FILE__)
  ActiveSupport::Dependencies.autoload_paths << path

  firm = Company.new(:type => 'ExtraFirm')
  assert_equal ExtraFirm, firm.class
ensure
  ActiveSupport::Dependencies.autoload_paths.reject! { |p| p == path }
  ActiveSupport::Dependencies.clear
end

# File activerecord/test/cases/inheritance_test.rb, line 207
def test_new_with_complex_inheritance
  assert_nothing_raised { Client.new(type: 'VerySpecialClient') }
end

# File activerecord/test/cases/inheritance_test.rb, line 199
def test_new_with_invalid_type
  assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => 'InvalidType') }
end

# File activerecord/test/cases/inheritance_test.rb, line 203
def test_new_with_unrelated_type
  assert_raise(ActiveRecord::SubclassNotFound) { Company.new(:type => 'Account') }
end

# File activerecord/test/cases/inheritance_test.rb, line 327
def test_scope_inherited_properly
  assert_nothing_raised { Company.of_first_firm }
  assert_nothing_raised { Client.of_first_firm }
end

# File activerecord/test/cases/inheritance_test.rb, line 43
def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = false
  item = Namespaced::Company.new
  assert_equal 'Company', item[:type]
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 52
def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
  old = ActiveRecord::Base.store_full_sti_class
  ActiveRecord::Base.store_full_sti_class = true
  item = Namespaced::Company.new
  assert_equal 'Namespaced::Company', item[:type]
ensure
  ActiveRecord::Base.store_full_sti_class = old
end

# File activerecord/test/cases/inheritance_test.rb, line 244
def test_update_all_within_inheritance
  Client.update_all "name = 'I am a client'"
  assert_equal "I am a client", Client.first.name
  # Order by added as otherwise Oracle tests were failing because of different order of results
  assert_equal "37signals", Firm.all.merge!(:order => "id").to_a.first.name
end

# File activesupport/lib/active_support/core_ext/object/to_query.rb, line 5
def to_param
  to_s
end

# File activesupport/lib/active_support/core_ext/object/to_query.rb, line 11
def to_query(key)
  "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
end

# File activesupport/lib/active_support/core_ext/object/try.rb, line 62
def try(*a, &b)
  try!(*a, &b) if a.empty? || respond_to?(a.first)
end

# File activesupport/lib/active_support/core_ext/object/try.rb, line 69
def try!(*a, &b)
  if a.empty? && block_given?
    if b.arity == 0
      instance_eval(&b)
    else
      yield self
    end
  else
    public_send(*a, &b)
  end
end

# File activesupport/lib/active_support/core_ext/uri.rb, line 9
def unescape(str, escaped = /%[a-fA-F\d]{2}/)
  # TODO: Are we actually sure that ASCII == UTF-8?
  # YK: My initial experiments say yes, but let's be sure please
  enc = str.encoding
  enc = Encoding::UTF_8 if enc == Encoding::US_ASCII
  str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
end

# File activerecord/test/cases/helper.rb, line 96
def verify_default_timezone_config
  if Time.zone != EXPECTED_ZONE
    $stderr.puts <<-MSG
\n#{self}
    Global state `Time.zone` was leaked.
      Expected: #{EXPECTED_ZONE}
      Got: #{Time.zone}
    MSG
  end
  if ActiveRecord::Base.default_timezone != EXPECTED_DEFAULT_TIMEZONE
    $stderr.puts <<-MSG
\n#{self}
    Global state `ActiveRecord::Base.default_timezone` was leaked.
      Expected: #{EXPECTED_DEFAULT_TIMEZONE}
      Got: #{ActiveRecord::Base.default_timezone}
    MSG
  end
  if ActiveRecord::Base.time_zone_aware_attributes != EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES
    $stderr.puts <<-MSG
\n#{self}
    Global state `ActiveRecord::Base.time_zone_aware_attributes` was leaked.
      Expected: #{EXPECTED_TIME_ZONE_AWARE_ATTRIBUTES}
      Got: #{ActiveRecord::Base.time_zone_aware_attributes}
    MSG
  end
end

# File activerecord/test/cases/helper.rb, line 62
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

# File activesupport/lib/active_support/core_ext/object/with_options.rb, line 65
def with_options(options, &block)
  option_merger = ActiveSupport::OptionMerger.new(self, options)
  block.arity.zero? ? option_merger.instance_eval(&block) : block.call(option_merger)
end

# File activerecord/test/cases/helper.rb, line 69
def with_timezone_config(cfg)
  verify_default_timezone_config

  old_default_zone = ActiveRecord::Base.default_timezone
  old_awareness = ActiveRecord::Base.time_zone_aware_attributes
  old_zone = Time.zone

  if cfg.has_key?(:default)
    ActiveRecord::Base.default_timezone = cfg[:default]
  end
  if cfg.has_key?(:aware_attributes)
    ActiveRecord::Base.time_zone_aware_attributes = cfg[:aware_attributes]
  end
  if cfg.has_key?(:zone)
    Time.zone = cfg[:zone]
  end
  yield
ensure
  ActiveRecord::Base.default_timezone = old_default_zone
  ActiveRecord::Base.time_zone_aware_attributes = old_awareness
  Time.zone = old_zone
end