blather 0.6.2 → 0.7.0

data/spec/blather/stanza/presence_spec.rb

@@ -2,79 +2,117 @@ require 'spec_helper'
 
 describe Blather::Stanza::Presence do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:presence, nil).must_equal Blather::Stanza::Presence
+    Blather::XMPPNode.class_from_registration(:presence, nil).should == Blather::Stanza::Presence
   end
 
   it 'must be importable' do
-    doc = parse_stanza '<presence type="probe"/>'
-    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Presence
+    Blather::XMPPNode.parse('<presence type="probe"/>').should be_instance_of Blather::Stanza::Presence
   end
 
   it 'ensures type is one of Blather::Stanza::Presence::VALID_TYPES' do
     presence = Blather::Stanza::Presence.new
-    lambda { presence.type = :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { presence.type = :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Presence::VALID_TYPES.each do |valid_type|
       presence.type = valid_type
-      presence.type.must_equal valid_type
+      presence.type.should == valid_type
     end
   end
 
   Blather::Stanza::Presence::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Blather::Stanza::Presence.new.must_respond_to :"#{valid_type}?"
+      Blather::Stanza::Presence.new.should respond_to :"#{valid_type}?"
     end
 
     it "returns true on call to (#{valid_type}?) if type == #{valid_type}" do
       method = "#{valid_type}?".to_sym
       pres = Blather::Stanza::Presence.new
       pres.type = valid_type
-      pres.must_respond_to method
-      pres.__send__(method).must_equal true
+      pres.should respond_to method
+      pres.__send__(method).should == true
     end
   end
 
+  it 'creates a C object when importing a node with a c child' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <c xmlns='http://jabber.org/protocol/caps'
+           hash='sha-1'
+           node='http://www.chatopus.com'
+           ver='zHyEOgxTrkpSdGcQKH8EFPLsriY='/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::C::InstanceMethods
+    s.node.should == 'http://www.chatopus.com'
+  end
+
   it 'creates a Status object when importing a node with type == nil' do
-    s = Blather::Stanza::Presence.import(parse_stanza('<presence/>').root)
-    s.must_be_kind_of Blather::Stanza::Presence::Status
-    s.state.must_equal :available
+    s = Blather::Stanza::Presence.parse('<presence/>')
+    s.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    s.state.should == :available
   end
 
   it 'creates a Status object when importing a node with type == "unavailable"' do
-    s = Blather::Stanza::Presence.import(parse_stanza('<presence type="unavailable"/>').root)
-    s.must_be_kind_of Blather::Stanza::Presence::Status
-    s.state.must_equal :unavailable
+    s = Blather::Stanza::Presence.parse('<presence type="unavailable"/>')
+    s.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    s.state.should == :unavailable
   end
 
   it 'creates a Subscription object when importing a node with type == "subscribe"' do
-    s = Blather::Stanza::Presence.import(parse_stanza('<presence type="subscribe"/>').root)
-    s.must_be_kind_of Blather::Stanza::Presence::Subscription
-    s.type.must_equal :subscribe
+    s = Blather::Stanza::Presence.parse('<presence type="subscribe"/>')
+    s.should be_kind_of Blather::Stanza::Presence::Subscription::InstanceMethods
+    s.type.should == :subscribe
   end
 
   it 'creates a MUC object when importing a node with a form in the MUC namespace' do
-    n = Blather::XMPPNode.new
-    x = Blather::XMPPNode.new 'x'
-    x.namespace = "http://jabber.org/protocol/muc"
-    n << x
-    s = Blather::Stanza::Presence.import(n)
-    s.must_be_kind_of Blather::Stanza::Presence::MUC
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <x xmlns='http://jabber.org/protocol/muc'/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::MUC::InstanceMethods
   end
 
   it 'creates a MUCUser object when importing a node with a form in the MUC#user namespace' do
-    n = Blather::XMPPNode.new
-    x = Blather::XMPPNode.new 'x'
-    x.namespace = "http://jabber.org/protocol/muc#user"
-    n << x
-    s = Blather::Stanza::Presence.import(n)
-    s.must_be_kind_of Blather::Stanza::Presence::MUCUser
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <x xmlns='http://jabber.org/protocol/muc#user'/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::MUCUser::InstanceMethods
   end
 
   it 'creates a Presence object when importing a node with type equal to something unknown' do
-    n = Blather::XMPPNode.new
-    n[:type] = :foo
-    s = Blather::Stanza::Presence.import(n)
-    s.must_be_kind_of Blather::Stanza::Presence
-    s.type.must_equal :foo
+    string = "<presence from='bard@shakespeare.lit/globe' type='foo'/>"
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence
+    s.type.should == :foo
+  end
+
+  it 'behaves like a C, a Status, and a MUCUser when all types of children are present' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <show>chat</show>
+        <c xmlns='http://jabber.org/protocol/caps'
+           hash='sha-1'
+           node='http://www.chatopus.com'
+           ver='zHyEOgxTrkpSdGcQKH8EFPLsriY='/>
+        <x xmlns='http://jabber.org/protocol/muc#user'>
+          <item affiliation='none'
+                jid='hag66@shakespeare.lit/pda'
+                role='participant'/>
+          <status code='100'/>
+          <status code='110'/>
+          <password>foobar</password>
+        </x>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.state.should == :chat
+    s.node.should == 'http://www.chatopus.com'
+    s.role.should == :participant
   end
 end

data/spec/blather/stanza/pubsub/affiliations_spec.rb

@@ -11,47 +11,47 @@ end
 
 describe Blather::Stanza::PubSub::Affiliations do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:affiliations, Blather::Stanza::PubSub.registered_ns).must_equal Blather::Stanza::PubSub::Affiliations
+    Blather::XMPPNode.class_from_registration(:affiliations, Blather::Stanza::PubSub.registered_ns).should == Blather::Stanza::PubSub::Affiliations
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.import(parse_stanza(affiliations_xml).root).must_be_instance_of Blather::Stanza::PubSub::Affiliations
+    Blather::XMPPNode.parse(affiliations_xml).should be_instance_of Blather::Stanza::PubSub::Affiliations
   end
 
   it 'ensures an affiliations node is present on create' do
     affiliations = Blather::Stanza::PubSub::Affiliations.new
-    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_nil
+    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_nil
   end
 
   it 'ensures an affiliations node exists when calling #affiliations' do
     affiliations = Blather::Stanza::PubSub::Affiliations.new
     affiliations.pubsub.remove_children :affiliations
-    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).must_be_nil
+    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).should be_nil
 
-    affiliations.affiliations.wont_be_nil
-    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_nil
+    affiliations.affiliations.should_not be_nil
+    affiliations.find_first('//ns:affiliations', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_nil
   end
 
   it 'defaults to a get node' do
-    Blather::Stanza::PubSub::Affiliations.new.type.must_equal :get
+    Blather::Stanza::PubSub::Affiliations.new.type.should == :get
   end
 
   it 'sets the host if requested' do
     aff = Blather::Stanza::PubSub::Affiliations.new :get, 'pubsub.jabber.local'
-    aff.to.must_equal Blather::JID.new('pubsub.jabber.local')
+    aff.to.should == Blather::JID.new('pubsub.jabber.local')
   end
 
   it 'can import an affiliates result node' do
     node = parse_stanza(affiliations_xml).root
 
     affiliations = Blather::Stanza::PubSub::Affiliations.new.inherit node
-    affiliations.size.must_equal 5
-    affiliations.list.must_equal control_affiliations
+    affiliations.size.should == 5
+    affiliations.list.should == control_affiliations
   end
 
   it 'will iterate over each affiliation' do
-    Blather::XMPPNode.import(parse_stanza(affiliations_xml).root).each do |type, nodes|
-      nodes.must_equal control_affiliations[type]
+    Blather::XMPPNode.parse(affiliations_xml).each do |type, nodes|
+      nodes.should == control_affiliations[type]
     end
   end
 end

data/spec/blather/stanza/pubsub/create_spec.rb

@@ -3,11 +3,11 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Create do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:create, 'http://jabber.org/protocol/pubsub').must_equal Blather::Stanza::PubSub::Create
+    Blather::XMPPNode.class_from_registration(:create, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Create
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.import(parse_stanza(<<-NODE).root).must_be_instance_of Blather::Stanza::PubSub::Create
+    Blather::XMPPNode.parse(<<-NODE).should be_instance_of Blather::Stanza::PubSub::Create
     <iq type='set'
         from='hamlet@denmark.lit/elsinore'
         to='pubsub.shakespeare.lit'
@@ -22,35 +22,35 @@ describe Blather::Stanza::PubSub::Create do
 
   it 'ensures a create node is present on create' do
     create = Blather::Stanza::PubSub::Create.new
-    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_empty
+    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
   end
 
   it 'ensures a configure node is present on create' do
     create = Blather::Stanza::PubSub::Create.new
-    create.find('//ns:pubsub/ns:configure', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_empty
+    create.find('//ns:pubsub/ns:configure', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
   end
 
   it 'ensures a create node exists when calling #create_node' do
     create = Blather::Stanza::PubSub::Create.new
     create.pubsub.remove_children :create
-    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).must_be_empty
+    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
 
-    create.create_node.wont_be_nil
-    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_empty
+    create.create_node.should_not be_nil
+    create.find('//ns:pubsub/ns:create', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
   end
 
   it 'defaults to a set node' do
     create = Blather::Stanza::PubSub::Create.new
-    create.type.must_equal :set
+    create.type.should == :set
   end
 
   it 'sets the host if requested' do
     create = Blather::Stanza::PubSub::Create.new :set, 'pubsub.jabber.local'
-    create.to.must_equal Blather::JID.new('pubsub.jabber.local')
+    create.to.should == Blather::JID.new('pubsub.jabber.local')
   end
 
   it 'sets the node' do
     create = Blather::Stanza::PubSub::Create.new :set, 'host', 'node-name'
-    create.node.must_equal 'node-name'
+    create.node.should == 'node-name'
   end
 end

data/spec/blather/stanza/pubsub/event_spec.rb

@@ -3,60 +3,60 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Event do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:event, 'http://jabber.org/protocol/pubsub#event').must_equal Blather::Stanza::PubSub::Event
+    Blather::XMPPNode.class_from_registration(:event, 'http://jabber.org/protocol/pubsub#event').should == Blather::Stanza::PubSub::Event
   end
 
   it 'is importable' do
-    Blather::XMPPNode.import(parse_stanza(event_notification_xml).root).must_be_instance_of Blather::Stanza::PubSub::Event
+    Blather::XMPPNode.parse(event_notification_xml).should be_instance_of Blather::Stanza::PubSub::Event
   end
 
   it 'ensures a query node is present on create' do
     evt = Blather::Stanza::PubSub::Event.new
-    evt.find('ns:event', :ns => Blather::Stanza::PubSub::Event.registered_ns).wont_be_empty
+    evt.find('ns:event', :ns => Blather::Stanza::PubSub::Event.registered_ns).should_not be_empty
   end
 
   it 'ensures an event node exists when calling #event_node' do
     evt = Blather::Stanza::PubSub::Event.new
     evt.remove_children :event
-    evt.find('*[local-name()="event"]').must_be_empty
+    evt.find('*[local-name()="event"]').should be_empty
 
-    evt.event_node.wont_be_nil
-    evt.find('ns:event', :ns => Blather::Stanza::PubSub::Event.registered_ns).wont_be_empty
+    evt.event_node.should_not be_nil
+    evt.find('ns:event', :ns => Blather::Stanza::PubSub::Event.registered_ns).should_not be_empty
   end
 
   it 'ensures an items node exists when calling #items_node' do
     evt = Blather::Stanza::PubSub::Event.new
     evt.remove_children :items
-    evt.find('*[local-name()="items"]').must_be_empty
+    evt.find('*[local-name()="items"]').should be_empty
 
-    evt.items_node.wont_be_nil
-    evt.find('ns:event/ns:items', :ns => Blather::Stanza::PubSub::Event.registered_ns).wont_be_empty
+    evt.items_node.should_not be_nil
+    evt.find('ns:event/ns:items', :ns => Blather::Stanza::PubSub::Event.registered_ns).should_not be_empty
   end
 
   it 'knows the associated node name' do
-    evt = Blather::XMPPNode.import(parse_stanza(event_with_payload_xml).root)
-    evt.node.must_equal 'princely_musings'
+    evt = Blather::XMPPNode.parse(event_with_payload_xml)
+    evt.node.should == 'princely_musings'
   end
 
   it 'ensures newly inherited items are PubSubItem objects' do
-    evt = Blather::XMPPNode.import(parse_stanza(event_with_payload_xml).root)
-    evt.items?.must_equal true
-    evt.retractions?.must_equal false
-    evt.items.map { |i| i.class }.uniq.must_equal [Blather::Stanza::PubSub::PubSubItem]
+    evt = Blather::XMPPNode.parse(event_with_payload_xml)
+    evt.items?.should == true
+    evt.retractions?.should == false
+    evt.items.map { |i| i.class }.uniq.should == [Blather::Stanza::PubSub::PubSubItem]
   end
 
   it 'will iterate over each item' do
-    evt = Blather::XMPPNode.import(parse_stanza(event_with_payload_xml).root)
-    evt.items.each { |i| i.class.must_equal Blather::Stanza::PubSub::PubSubItem }
+    evt = Blather::XMPPNode.parse(event_with_payload_xml)
+    evt.items.each { |i| i.class.should == Blather::Stanza::PubSub::PubSubItem }
   end
 
   it 'handles receiving subscription ids' do
-    evt = Blather::XMPPNode.import(parse_stanza(event_subids_xml).root)
-    evt.subscription_ids.must_equal ['123-abc', '004-yyy']
+    evt = Blather::XMPPNode.parse(event_subids_xml)
+    evt.subscription_ids.should == ['123-abc', '004-yyy']
   end
 
   it 'can have a list of retractions' do
-    evt = Blather::XMPPNode.import(parse_stanza(<<-NODE).root)
+    evt = Blather::XMPPNode.parse(<<-NODE)
     <message from='pubsub.shakespeare.lit' to='francisco@denmark.lit' id='foo'>
       <event xmlns='http://jabber.org/protocol/pubsub#event'>
         <items node='princely_musings'>
@@ -65,34 +65,34 @@ describe Blather::Stanza::PubSub::Event do
       </event>
     </message>
     NODE
-    evt.retractions?.must_equal true
-    evt.items?.must_equal false
-    evt.retractions.must_equal %w[ae890ac52d0df67ed7cfdf51b644e901]
+    evt.retractions?.should == true
+    evt.items?.should == false
+    evt.retractions.should == %w[ae890ac52d0df67ed7cfdf51b644e901]
   end
 
   it 'can be a purge' do
-    evt = Blather::XMPPNode.import(parse_stanza(<<-NODE).root)
+    evt = Blather::XMPPNode.parse(<<-NODE)
     <message from='pubsub.shakespeare.lit' to='francisco@denmark.lit' id='foo'>
       <event xmlns='http://jabber.org/protocol/pubsub#event'>
         <purge node='princely_musings'/>
       </event>
     </message>
     NODE
-    evt.purge?.wont_be_nil
-    evt.node.must_equal 'princely_musings'
+    evt.purge?.should_not be_nil
+    evt.node.should == 'princely_musings'
   end
 
   it 'can be a subscription notification' do
-    evt = Blather::XMPPNode.import(parse_stanza(<<-NODE).root)
+    evt = Blather::XMPPNode.parse(<<-NODE)
     <message from='pubsub.shakespeare.lit' to='francisco@denmark.lit' id='foo'>
       <event xmlns='http://jabber.org/protocol/pubsub#event'>
         <subscription jid='francisco@denmark.lit' subscription='subscribed' node='/example.com/test'/>
       </event>
     </message>
     NODE
-    evt.subscription?.wont_be_nil
-    evt.subscription[:jid].must_equal 'francisco@denmark.lit'
-    evt.subscription[:subscription].must_equal 'subscribed'
-    evt.subscription[:node].must_equal '/example.com/test'
+    evt.subscription?.should_not be_nil
+    evt.subscription[:jid].should == 'francisco@denmark.lit'
+    evt.subscription[:subscription].should == 'subscribed'
+    evt.subscription[:node].should == '/example.com/test'
   end
 end

data/spec/blather/stanza/pubsub/items_spec.rb

@@ -3,43 +3,43 @@ require 'fixtures/pubsub'
 
 describe Blather::Stanza::PubSub::Items do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:items, 'http://jabber.org/protocol/pubsub').must_equal Blather::Stanza::PubSub::Items
+    Blather::XMPPNode.class_from_registration(:items, 'http://jabber.org/protocol/pubsub').should == Blather::Stanza::PubSub::Items
   end
 
   it 'can be imported' do
-    Blather::XMPPNode.import(parse_stanza(items_all_nodes_xml).root).must_be_instance_of Blather::Stanza::PubSub::Items
+    Blather::XMPPNode.parse(items_all_nodes_xml).should be_instance_of Blather::Stanza::PubSub::Items
   end
 
   it 'ensures an items node is present on create' do
     items = Blather::Stanza::PubSub::Items.new
-    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_empty
+    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
   end
 
   it 'ensures an items node exists when calling #items' do
     items = Blather::Stanza::PubSub::Items.new
     items.pubsub.remove_children :items
-    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).must_be_empty
+    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).should be_empty
 
-    items.items.wont_be_nil
-    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).wont_be_empty
+    items.items.should_not be_nil
+    items.find('//ns:pubsub/ns:items', :ns => Blather::Stanza::PubSub.registered_ns).should_not be_empty
   end
 
   it 'defaults to a get node' do
     aff = Blather::Stanza::PubSub::Items.new
-    aff.type.must_equal :get
+    aff.type.should == :get
   end
 
   it 'ensures newly inherited items are PubSubItem objects' do
-    items = Blather::XMPPNode.import(parse_stanza(items_all_nodes_xml).root)
-    items.map { |i| i.class }.uniq.must_equal [Blather::Stanza::PubSub::PubSubItem]
+    items = Blather::XMPPNode.parse(items_all_nodes_xml)
+    items.map { |i| i.class }.uniq.should == [Blather::Stanza::PubSub::PubSubItem]
   end
 
   it 'will iterate over each item' do
     n = parse_stanza items_all_nodes_xml
     items = Blather::Stanza::PubSub::Items.new.inherit n.root
     count = 0
-    items.each { |i| i.must_be_instance_of Blather::Stanza::PubSub::PubSubItem; count += 1 }
-    count.must_equal 4
+    items.each { |i| i.should be_instance_of Blather::Stanza::PubSub::PubSubItem; count += 1 }
+    count.should == 4
   end
 
   it 'can create an items request node to request all items' do
@@ -47,9 +47,9 @@ describe Blather::Stanza::PubSub::Items do
     node = 'princely_musings'
 
     items = Blather::Stanza::PubSub::Items.request host, node
-    items.find("//ns:items[@node=\"#{node}\"]", :ns => Blather::Stanza::PubSub.registered_ns).size.must_equal 1
-    items.to.must_equal Blather::JID.new(host)
-    items.node.must_equal node
+    items.find("//ns:items[@node=\"#{node}\"]", :ns => Blather::Stanza::PubSub.registered_ns).size.should == 1
+    items.to.should == Blather::JID.new(host)
+    items.node.should == node
   end
 
   it 'can create an items request node to request some items' do
@@ -60,9 +60,9 @@ describe Blather::Stanza::PubSub::Items do
     items_xpath = items.map { |i| "@id=\"#{i}\"" } * ' or '
 
     items = Blather::Stanza::PubSub::Items.request host, node, items
-    items.find("//ns:items[@node=\"#{node}\"]/ns:item[#{items_xpath}]", :ns => Blather::Stanza::PubSub.registered_ns).size.must_equal 2
-    items.to.must_equal Blather::JID.new(host)
-    items.node.must_equal node
+    items.find("//ns:items[@node=\"#{node}\"]/ns:item[#{items_xpath}]", :ns => Blather::Stanza::PubSub.registered_ns).size.should == 2
+    items.to.should == Blather::JID.new(host)
+    items.node.should == node
   end
 
   it 'can create an items request node to request "max_number" of items' do
@@ -71,9 +71,9 @@ describe Blather::Stanza::PubSub::Items do
     max = 3
 
     items = Blather::Stanza::PubSub::Items.request host, node, nil, max
-    items.find("//ns:pubsub/ns:items[@node=\"#{node}\" and @max_items=\"#{max}\"]", :ns => Blather::Stanza::PubSub.registered_ns).size.must_equal 1
-    items.to.must_equal Blather::JID.new(host)
-    items.node.must_equal node
-    items.max_items.must_equal max
+    items.find("//ns:pubsub/ns:items[@node=\"#{node}\" and @max_items=\"#{max}\"]", :ns => Blather::Stanza::PubSub.registered_ns).size.should == 1
+    items.to.should == Blather::JID.new(host)
+    items.node.should == node
+    items.max_items.should == max
   end
 end