3mix-castronaut 0.5.0.2

data/vendor/activerecord/test/cases/inheritance_test.rb

@@ -0,0 +1,262 @@
+require "cases/helper"
+require 'models/company'
+require 'models/project'
+require 'models/subscriber'
+
+class InheritanceTest < ActiveRecord::TestCase
+  fixtures :companies, :projects, :subscribers, :accounts
+
+  def test_class_with_store_full_sti_class_returns_full_name
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    assert_equal 'Namespaced::Company', Namespaced::Company.sti_name
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  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
+
+  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
+  
+  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
+  
+  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
+
+  def test_company_descends_from_active_record
+    assert_raise(NoMethodError) { 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
+
+  def test_a_bad_type_column
+    #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
+    if current_adapter?(:SQLServerAdapter, :SybaseAdapter)
+      Company.connection.execute "SET IDENTITY_INSERT companies ON"
+    end
+    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
+
+    #We then need to turn it back Off before continuing.
+    if current_adapter?(:SQLServerAdapter, :SybaseAdapter)
+      Company.connection.execute "SET IDENTITY_INSERT companies OFF"
+    end
+    assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }
+  end
+
+  def test_inheritance_find
+    assert Company.find(1).kind_of?(Firm), "37signals should be a firm"
+    assert Firm.find(1).kind_of?(Firm), "37signals should be a firm"
+    assert Company.find(2).kind_of?(Client), "Summit should be a client"
+    assert Client.find(2).kind_of?(Client), "Summit should be a client"
+  end
+
+  def test_alt_inheritance_find
+    switch_to_alt_inheritance_column
+    test_inheritance_find
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_find_all
+    companies = Company.find(:all, :order => 'id')
+    assert companies[0].kind_of?(Firm), "37signals should be a firm"
+    assert companies[1].kind_of?(Client), "Summit should be a client"
+  end
+
+  def test_alt_inheritance_find_all
+    switch_to_alt_inheritance_column
+    test_inheritance_find_all
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_save
+    firm = Firm.new
+    firm.name = "Next Angle"
+    firm.save
+
+    next_angle = Company.find(firm.id)
+    assert next_angle.kind_of?(Firm), "Next Angle should be a firm"
+  end
+
+  def test_alt_inheritance_save
+    switch_to_alt_inheritance_column
+    test_inheritance_save
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_condition
+    assert_equal 9, Company.count
+    assert_equal 2, Firm.count
+    assert_equal 3, Client.count
+  end
+
+  def test_alt_inheritance_condition
+    switch_to_alt_inheritance_column
+    test_inheritance_condition
+    switch_to_default_inheritance_column
+  end
+
+  def test_finding_incorrect_type_data
+    assert_raises(ActiveRecord::RecordNotFound) { Firm.find(2) }
+    assert_nothing_raised   { Firm.find(1) }
+  end
+
+  def test_alt_finding_incorrect_type_data
+    switch_to_alt_inheritance_column
+    test_finding_incorrect_type_data
+    switch_to_default_inheritance_column
+  end
+
+  def test_update_all_within_inheritance
+    Client.update_all "name = 'I am a client'"
+    assert_equal "I am a client", Client.find(:all).first.name
+    assert_equal "37signals", Firm.find(:all).first.name
+  end
+
+  def test_alt_update_all_within_inheritance
+    switch_to_alt_inheritance_column
+    test_update_all_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_destroy_all_within_inheritance
+    Client.destroy_all
+    assert_equal 0, Client.count
+    assert_equal 2, Firm.count
+  end
+
+  def test_alt_destroy_all_within_inheritance
+    switch_to_alt_inheritance_column
+    test_destroy_all_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_find_first_within_inheritance
+    assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'")
+    assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'")
+    assert_nil Client.find(:first, :conditions => "name = '37signals'")
+  end
+
+  def test_alt_find_first_within_inheritance
+    switch_to_alt_inheritance_column
+    test_find_first_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_complex_inheritance
+    very_special_client = VerySpecialClient.create("name" => "veryspecial")
+    assert_equal very_special_client, VerySpecialClient.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size
+    assert_equal very_special_client, Client.find(very_special_client.id)
+  end
+
+  def test_alt_complex_inheritance
+    switch_to_alt_inheritance_column
+    test_complex_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_eager_load_belongs_to_something_inherited
+    account = Account.find(1, :include => :firm)
+    assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed"
+  end
+
+  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.find(1, :include => :firm)
+    end
+  end
+
+  def test_alt_eager_loading
+    switch_to_alt_inheritance_column
+    test_eager_load_belongs_to_something_inherited
+    switch_to_default_inheritance_column
+  end
+
+  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
+
+  private
+    def switch_to_alt_inheritance_column
+      # we don't want misleading test results, so get rid of the values in the type column
+      Company.find(:all, :order => 'id').each do |c|
+        c['type'] = nil
+        c.save
+      end
+      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
+      Company.set_inheritance_column('ruby_type')
+    end
+    def switch_to_default_inheritance_column
+      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
+      Company.set_inheritance_column('type')
+    end
+end
+
+
+class InheritanceComputeTypeTest < ActiveRecord::TestCase
+  fixtures :companies
+
+  def setup
+    ActiveSupport::Dependencies.log_activity = true
+  end
+
+  def teardown
+    ActiveSupport::Dependencies.log_activity = false
+    self.class.const_remove :FirmOnTheFly rescue nil
+    Firm.const_remove :FirmOnTheFly rescue nil
+  end
+
+  def test_instantiation_doesnt_try_to_require_corresponding_file
+    foo = Firm.find(:first).clone
+    foo.ruby_type = foo.type = 'FirmOnTheFly'
+    foo.save!
+
+    # Should fail without FirmOnTheFly in the type condition.
+    assert_raise(ActiveRecord::RecordNotFound) { Firm.find(foo.id) }
+
+    # Nest FirmOnTheFly in the test case where Dependencies won't see it.
+    self.class.const_set :FirmOnTheFly, Class.new(Firm)
+    assert_raise(ActiveRecord::SubclassNotFound) { Firm.find(foo.id) }
+
+    # Nest FirmOnTheFly in Firm where Dependencies will see it.
+    # This is analogous to nesting models in a migration.
+    Firm.const_set :FirmOnTheFly, Class.new(Firm)
+
+    # And instantiate will find the existing constant rather than trying
+    # to require firm_on_the_fly.
+    assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find(foo.id) }
+  end
+end

data/vendor/activerecord/test/cases/invalid_date_test.rb

@@ -0,0 +1,24 @@
+require 'cases/helper'
+require 'models/topic'
+
+class InvalidDateTest < Test::Unit::TestCase
+  def test_assign_valid_dates
+    valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
+
+    invalid_dates = [[2007, 11, 31], [1993, 2, 29], [2007, 2, 29]]
+
+    topic = Topic.new
+
+    valid_dates.each do |date_src|
+      topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+      assert_equal(topic.last_read, Date.new(*date_src))
+    end
+
+    invalid_dates.each do |date_src|
+      assert_nothing_raised do
+        topic = Topic.new({"last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s})
+        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behaviour of the Time object")
+      end
+    end
+  end
+end

data/vendor/activerecord/test/cases/json_serialization_test.rb

@@ -0,0 +1,205 @@
+require "cases/helper"
+require 'models/contact'
+require 'models/post'
+require 'models/author'
+require 'models/tagging'
+require 'models/tag'
+require 'models/comment'
+
+class JsonSerializationTest < ActiveRecord::TestCase
+  class NamespacedContact < Contact
+    column :name,        :string
+  end
+
+  def setup
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :avatar      => 'binarydata',
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+  end
+
+  def test_should_demodulize_root_in_json
+    NamespacedContact.include_root_in_json = true
+    @contact = NamespacedContact.new :name => 'whatever'
+    json = @contact.to_json
+    assert_match %r{^\{"namespaced_contact": \{}, json
+  end
+
+  def test_should_include_root_in_json
+    Contact.include_root_in_json = true
+    json = @contact.to_json
+
+    assert_match %r{^\{"contact": \{}, json
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome": true}, json
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  ensure
+    Contact.include_root_in_json = false
+  end
+
+  def test_should_encode_all_encodable_attributes
+    json = @contact.to_json
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome": true}, json
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_only
+    json = @contact.to_json(:only => [:name, :age])
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert_no_match %r{"awesome": true}, json
+    assert !json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_no_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_except
+    json = @contact.to_json(:except => [:name, :age])
+
+    assert_no_match %r{"name": "Konata Izumi"}, json
+    assert_no_match %r{"age": 16}, json
+    assert_match %r{"awesome": true}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_methods_are_called_on_object
+    # Define methods on fixture.
+    def @contact.label; "Has cheezburger"; end
+    def @contact.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_match %r{"label": "Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{"label": "Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote": "Constraints are liberating"}, methods_json
+  end
+end
+
+class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
+  fixtures :authors, :posts, :comments, :tags, :taggings
+
+  def setup
+    @david = authors(:david)
+    @mary = authors(:mary)
+  end
+
+  def test_includes_uses_association_name
+    json = @david.to_json(:include => :posts)
+
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"id": 1}, json
+    assert_match %r{"name": "David"}, json
+
+    assert_match %r{"author_id": 1}, json
+    assert_match %r{"title": "Welcome to the weblog"}, json
+    assert_match %r{"body": "Such a lovely day"}, json
+
+    assert_match %r{"title": "So I was thinking"}, json
+    assert_match %r{"body": "Like I hopefully always am"}, json
+  end
+
+  def test_includes_uses_association_name_and_applies_attribute_filters
+    json = @david.to_json(:include => { :posts => { :only => :title } })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"title": "Welcome to the weblog"}, json
+    assert_no_match %r{"body": "Such a lovely day"}, json
+
+    assert_match %r{"title": "So I was thinking"}, json
+    assert_no_match %r{"body": "Like I hopefully always am"}, json
+  end
+
+  def test_includes_fetches_second_level_associations
+    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"comments": \[}, json
+    assert_match %r{\{"body": "Thank you again for the welcome"\}}, json
+    assert_match %r{\{"body": "Don't think too hard"\}}, json
+    assert_no_match %r{"post_id": }, json
+  end
+
+  def test_includes_fetches_nth_level_associations
+    json = @david.to_json(
+      :include => {
+        :posts => {
+          :include => {
+            :taggings => {
+              :include => {
+                :tag => { :only => :name }
+              }
+            }
+          }
+        }
+    })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"taggings": \[}, json
+    assert_match %r{"tag": \{"name": "General"\}}, json
+  end
+
+  def test_should_not_call_methods_on_associations_that_dont_respond
+    def @david.favorite_quote; "Constraints are liberating"; end
+    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
+
+    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_match %r{"favorite_quote": "Constraints are liberating"}, json
+    assert_equal %r{"favorite_quote": }.match(json).size, 1
+  end
+
+  def test_should_allow_only_option_for_list_of_authors
+    authors = [@david, @mary]
+
+    assert_equal %([{"name": "David"}, {"name": "Mary"}]), authors.to_json(:only => :name)
+  end
+
+  def test_should_allow_except_option_for_list_of_authors
+    authors = [@david, @mary]
+
+    assert_equal %([{"id": 1}, {"id": 2}]), authors.to_json(:except => [:name, :author_address_id, :author_address_extra_id])
+  end
+
+  def test_should_allow_includes_for_list_of_authors
+    authors = [@david, @mary]
+    json = authors.to_json(
+      :only => :name,
+      :include => {
+        :posts => { :only => :id }
+      }
+    )
+
+    ['"name": "David"', '"posts": [', '{"id": 1}', '{"id": 2}', '{"id": 4}',
+     '{"id": 5}', '{"id": 6}', '"name": "Mary"', '"posts": [{"id": 7}]'].each do |fragment|
+      assert json.include?(fragment), json
+     end
+  end
+
+  def test_should_allow_options_for_hash_of_authors
+    authors_hash = {
+      1 => @david,
+      2 => @mary
+    }
+
+    assert_equal %({1: {"name": "David"}}), authors_hash.to_json(:only => [1, :name])
+  end
+end

data/vendor/activerecord/test/cases/lifecycle_test.rb

@@ -0,0 +1,193 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/developer'
+require 'models/reply'
+require 'models/minimalistic'
+
+class Topic; def after_find() end end
+class Developer; def after_find() end end
+class SpecialDeveloper < Developer; end
+
+class TopicManualObserver
+  include Singleton
+
+  attr_reader :action, :object, :callbacks
+
+  def initialize
+    Topic.add_observer(self)
+    @callbacks = []
+  end
+
+  def update(callback_method, object)
+    @callbacks << { "callback_method" => callback_method, "object" => object }
+  end
+
+  def has_been_notified?
+    !@callbacks.empty?
+  end
+end
+
+class TopicaAuditor < ActiveRecord::Observer
+  observe :topic
+
+  attr_reader :topic
+
+  def after_find(topic)
+    @topic = topic
+  end
+end
+
+class TopicObserver < ActiveRecord::Observer
+  attr_reader :topic
+
+  def after_find(topic)
+    @topic = topic
+  end
+end
+
+class MinimalisticObserver < ActiveRecord::Observer
+  attr_reader :minimalistic
+
+  def after_find(minimalistic)
+    @minimalistic = minimalistic
+  end
+end
+
+class MultiObserver < ActiveRecord::Observer
+  attr_reader :record
+
+  def self.observed_class() [ Topic, Developer ] end
+
+  cattr_reader :last_inherited
+  @@last_inherited = nil
+
+  def observed_class_inherited_with_testing(subclass)
+    observed_class_inherited_without_testing(subclass)
+    @@last_inherited = subclass
+  end
+
+  alias_method_chain :observed_class_inherited, :testing
+
+  def after_find(record)
+    @record = record
+  end
+end
+
+class LifecycleTest < ActiveRecord::TestCase
+  fixtures :topics, :developers, :minimalistics
+
+  def test_before_destroy
+    original_count = Topic.count
+    (topic_to_be_destroyed = Topic.find(1)).destroy
+    assert_equal original_count - (1 + topic_to_be_destroyed.replies.size), Topic.count
+  end
+
+  def test_after_save
+    ActiveRecord::Base.observers = :topic_manual_observer
+    ActiveRecord::Base.instantiate_observers
+
+    topic = Topic.find(1)
+    topic.title = "hello"
+    topic.save
+
+    assert TopicManualObserver.instance.has_been_notified?
+    assert_equal :after_save, TopicManualObserver.instance.callbacks.last["callback_method"]
+  end
+
+  def test_observer_update_on_save
+    ActiveRecord::Base.observers = TopicManualObserver
+    ActiveRecord::Base.instantiate_observers
+
+    topic = Topic.find(1)
+    assert TopicManualObserver.instance.has_been_notified?
+    assert_equal :after_find, TopicManualObserver.instance.callbacks.first["callback_method"]
+  end
+
+  def test_auto_observer
+    topic_observer = TopicaAuditor.instance
+    assert_nil TopicaAuditor.observed_class
+    assert_equal [Topic], TopicaAuditor.instance.observed_classes.to_a
+
+    topic = Topic.find(1)
+    assert_equal topic.title, topic_observer.topic.title
+  end
+
+  def test_inferred_auto_observer
+    topic_observer = TopicObserver.instance
+    assert_equal Topic, TopicObserver.observed_class
+
+    topic = Topic.find(1)
+    assert_equal topic.title, topic_observer.topic.title
+  end
+
+  def test_observing_two_classes
+    multi_observer = MultiObserver.instance
+
+    topic = Topic.find(1)
+    assert_equal topic.title, multi_observer.record.title
+
+    developer = Developer.find(1)
+    assert_equal developer.name, multi_observer.record.name
+  end
+
+  def test_observing_subclasses
+    multi_observer = MultiObserver.instance
+
+    developer = SpecialDeveloper.find(1)
+    assert_equal developer.name, multi_observer.record.name
+
+    klass = Class.new(Developer)
+    assert_equal klass, multi_observer.last_inherited
+
+    developer = klass.find(1)
+    assert_equal developer.name, multi_observer.record.name
+  end
+
+  def test_after_find_can_be_observed_when_its_not_defined_on_the_model
+    observer = MinimalisticObserver.instance
+    assert_equal Minimalistic, MinimalisticObserver.observed_class
+
+    minimalistic = Minimalistic.find(1)
+    assert_equal minimalistic, observer.minimalistic
+  end
+
+  def test_after_find_can_be_observed_when_its_defined_on_the_model
+    observer = TopicObserver.instance
+    assert_equal Topic, TopicObserver.observed_class
+
+    topic = Topic.find(1)
+    assert_equal topic, observer.topic
+  end
+
+  def test_after_find_is_not_created_if_its_not_used
+    # use a fresh class so an observer can't have defined an
+    # after_find on it
+    model_class = Class.new(ActiveRecord::Base)
+    observer_class = Class.new(ActiveRecord::Observer)
+    observer_class.observe(model_class)
+
+    observer = observer_class.instance
+
+    assert !model_class.method_defined?(:after_find)
+  end
+
+  def test_after_find_is_not_clobbered_if_it_already_exists
+    # use a fresh observer class so we can instantiate it (Observer is
+    # a Singleton)
+    model_class = Class.new(ActiveRecord::Base) do
+      def after_find; end
+    end
+    original_method = model_class.instance_method(:after_find)
+    observer_class = Class.new(ActiveRecord::Observer) do
+      def after_find; end
+    end
+    observer_class.observe(model_class)
+
+    observer = observer_class.instance
+    assert_equal original_method, model_class.instance_method(:after_find)
+  end
+
+  def test_invalid_observer
+    assert_raise(ArgumentError) { Topic.observers = Object.new; Topic.instantiate_observers }
+  end
+end