<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE scenario SYSTEM "sipp.dtd">

<!-- This program is free software; you can redistribute it and/or      -->
<!-- modify it under the terms of the GNU General Public License as     -->
<!-- published by the Free Software Foundation; either version 2 of the -->
<!-- License, or (at your option) any later version.                    -->
<!--                                                                    -->
<!-- This program is distributed in the hope that it will be useful,    -->
<!-- but WITHOUT ANY WARRANTY; without even the implied warranty of     -->
<!-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the      -->
<!-- GNU General Public License for more details.                       -->
<!--                                                                    -->
<!-- You should have received a copy of the GNU General Public License  -->
<!-- along with this program; if not, write to the                      -->
<!-- Free Software Foundation, Inc.,                                    -->
<!-- 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA             -->
<!--                                                                    -->

<scenario name="MWI server with immediate final notify">
  <recv request="SUBSCRIBE" crlf="true">
    <action>
	<ereg regexp=".*" search_in="hdr" header="From" assign_to="3"/>
	<ereg regexp="sip:(.*)>" search_in="hdr" header="Contact" assign_to="4,5"/>
        <assign assign_to="4" variable="5" />
    </action>
  </recv>


  <send>
    <![CDATA[

      SIP/2.0 200 OK
      [last_Via:]
      [last_From:]
      [last_To:];tag=[call_number]
      [last_Call-ID:]
      [last_CSeq:]
      Contact: <sip:sipp@[local_ip]:[local_port]>
      Content-Length: 0
      Expires: 600
    ]]>
  </send>

  <!-- initial notify is final notify -->
  <send retrans="500">
    <![CDATA[
      NOTIFY sip:[$5] SIP/2.0
      Via: SIP/2.0/[transport] [local_ip]:[local_port];rport;branch=[branch]
      From: sipp <sip:sipp@[local_ip]>;tag=[call_number]
      To[$3]
      Call-ID: [call_id]
      Cseq: 1 NOTIFY
      Contact: sip:sipp@[local_ip]:[local_port]
      Max-Forwards: 70
      Event: message-summary
      Subscription-State: terminated;reason=goinghome
      Content-Type: application/simple-message-summary
      Content-Length: [len]

      Messages-Waiting: yes
      Voice-Message: 4/8 (1/2)

    ]]>
  </send>

   <recv response="200">
   </recv>

  <pause milliseconds="5000"/> 

  <!-- definition of the response time repartition table (unit is ms)   -->
  <ResponseTimeRepartition value="10, 20, 30, 40, 50, 100, 150, 200"/>

  <!-- definition of the call length repartition table (unit is ms)     -->
  <CallLengthRepartition value="10, 50, 100, 500, 1000, 5000, 10000"/>

</scenario>

