Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
   * Conditions Of Use
3
   *
4
   * This software was developed by employees of the National Institute of
5
   * Standards and Technology (NIST), and others.
6
   * This software is has been contributed to the public domain.
7
   * As a result, a formal license is not needed to use the software.
8
   *
9
   * This software is provided "AS IS."
10
  * NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
11
  * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
12
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
13
  * AND DATA ACCURACY.  NIST does not warrant or make any representations
14
  * regarding the use of the software or the results thereof, including but
15
  * not limited to the correctness, accuracy, reliability or usefulness of
16
  * the software.
17
  *
18
  *
19
  */
20
  package test.tck.msgflow;
21
  
22
  import  junit.framework.*;
23
  
24
  import javax.sip.*;
27
  import java.util.*;
28
  import java.text.*;
29
  import test.tck.*;

* The test tries to verify that Invite Server Transactions correctly change states as specified by the rfc3261. The Reference Implementation is used to send requests and a Tested Implementation ServerTransaction's states are queried and compared to those in the state machine described in section 17.2.1 of rfc3261 

                              |INVITE
                              |pass INV to TU
            INVITE             V send 100 if TU won't in 200ms
            send response+-----------+
                +--------|           |--------+101-199 from TU
                |        | Proceeding|        |send response
                +------->|           |<-------+
                         |           |          Transport Err.
                         |           |          Inform TU
                         |           |--------------->+
                         +-----------+                |
            300-699 from TU |     |2xx from TU        |
            send response   |     |send response      |
                            |     +------------------>+
                            |                         |
            INVITE          V          Timer G fires  |
            send response+-----------+ send response  |
                +--------|           |--------+       |
                |        | Completed |        |       |
                +------->|           |<-------+       |
                         +-----------+                |
                            |     |                   |
                        ACK |     |                   |
                        -   |     +------------------>+
                            |        Timer H fires    |
                            V        or Transport Err.|
                         +-----------+  Inform TU     |
                         |           |                |
                         | Confirmed |                |
                         |           |                |
                         +-----------+                |
                               |                      |
                               |Timer I fires         |
                               |-                     |
                               |                      |
                               V                      |
                         +-----------+                |
                         |           |                |
                         | Terminated|<---------------+
                         |           |
                         +-----------+

              Figure 7: INVITE server transaction

Author(s):
Emil Ivov Network Research Team, Louis Pasteur University, Strasbourg, France. This code is in the public domain.
Version:
1.0
91
  
92
  
94
      extends MessageFlowHarness {
95
  
97
          super(name);
98
      }
99
  
100
     //==================== tests ==============================
101
     
Tries to steer a TI server transaction through the following scenario Proceeding-->Completed-->Confirmed-->Terminated. Apart from state transitions, we also test, retransmissions and proper hiding/passing of messages to the TU. 
106
 
107
     public void testProceedingCompletedConfirmedScenario() {
108
         try {
109
             Request invite = createRiInviteRequest(null, null, null);
110
             SipEventCollector responseCollector = new SipEventCollector();
111
             //Before Sending the request we should first register a listener with the
112
             //RI that would catch the TRYING response
113
             try {
114
                 responseCollector.collectResponseEvent();
115
             } catch (TooManyListenersException ex) {
116
                 throw new TckInternalError(
117
                     "Failed to register a SipListener with an RI SipProvider",
118
                     ex);
119
             }
120
             //Send the initial request
121
             try {
122
                 .collectRequestEvent();
123
                 .sendRequest(invite);
124
             } catch (SipException ex) {
125
                 throw new TckInternalError(
126
                     "A SipExceptionOccurred while trying to send request!",
127
                     ex);
128
             } catch (TooManyListenersException ex) {
129
                 throw new TiUnexpectedError(
130
                     "Failed to register a SipListener with a TI SipProvider",
131
                     ex);
132
             }
133
             waitForMessage();
134
             RequestEvent inviteReceivedEvent =
135
                 .extractCollectedRequestEvent();
136
             if (inviteReceivedEvent == null
137
                 || inviteReceivedEvent.getRequest() == null)
138
                 throw new TiUnexpectedError("The initial invite request was not received by the TI!");
139
             //Let's create the transaction
140
             ServerTransaction tran = null;
141
             try {
142
                 tran =
143
                     .getNewServerTransaction(
144
                         inviteReceivedEvent.getRequest());
145
             } catch (Exception ex) {
146
                 ex.printStackTrace();
147
                 fail(
148
                     ex.getClass().getName()
149
                         + "was thrown while trying to "
150
                         + "create the server transaction");
151
             }
152
             assertNotNull(
153
                 "tiSipProvider.getNewServerTransaction() returned null",
154
                 tran);
155
             //Check whether a TRYING response has been sent.
156
             //wait for the trying response
157
             waitForMessage();
158
             // At this point state must be PROCEEDING
159
             assertEquals(., tran.getState());
160
             ResponseEvent responseEvent =
161
                 responseCollector.extractCollectedResponseEvent();
162
             assertNotNull(
163
                 "No TRYING response has been sent by the TI upon reception "
164
                     + "of an INVITE request",
165
                 responseEvent);
166
             assertTrue(
167
                 "A response different from 100 was sent by the TI upon "
168
                     + "reception of INVITE",
169
                 . == responseEvent.getResponse().getStatusCode());
170
             //Resend the invite and see that a TRYING response is resent
171
             try {
172
                 //listen for the Trying response
173
                 responseCollector.collectResponseEvent();
174
             } catch (TooManyListenersException ex) {
175
                 throw new TckInternalError(
176
                     "Failed to register a SipListener with an RI SipProvider",
177
                     ex);
178
             }
179
             try {
180
                 .collectRequestEvent();
181
                 .sendRequest(invite);
182
             } catch (SipException ex) {
183
                 throw new TckInternalError(
184
                     "A SipExceptionOccurred while trying to send request!",
185
                     ex);
186
             } catch (TooManyListenersException ex) {
187
                 throw new TiUnexpectedError(
188
                     "Failed to register a SipListener with a TI SipProvider",
189
                     ex);
190
             }
191
             //Wait for the INVITE
192
             waitForMessage();
193
             inviteReceivedEvent = .extractCollectedRequestEvent();
194
             assertNull(
195
                 "Retransmitted INVITEs should not be passed to the TU",
196
                 inviteReceivedEvent);
197
             //Wait for a retransmitted TRYING response
198
             waitForMessage();
199
             //Verify whether there was a TRYING response
200
             responseEvent = responseCollector.extractCollectedResponseEvent();
201
             assertNotNull(
202
                 "No TRYING response has been sent by the TI upon reception "
203
                     + "of an INVITE request",
204
                 responseEvent);
205
             assertTrue(
206
                 "A response different from 100 was sent by the TI upon "
207
                     + "reception of INVITE",
208
                 . == responseEvent.getResponse().getStatusCode());
209
 
210
             Response ringing = null;
211
             try {
212
                 ringing =
213
                     .createResponse(
214
                         .,
215
                         tran.getRequest());
216
                 ((ToHeader) ringing.getHeader(.)).setTag(
217
                     Integer.toString(hashCode()));
218
                 addStatus(tran.getRequest(), ringing);
219
                 // BUG report from Ben Evans:
220
                 // set contact header on dialog-creating response
221
                 ringing.setHeader(createTiContact());
222
             } catch (ParseException ex) {
223
                 throw new TiUnexpectedError(
224
                     "A ParseException was thrown while trying to create a ringing "
225
                         + "response using TI",
226
                     ex);
227
             }
228
             //Create & send RINGING. See that it is properly sent
229
             //and that tran state doesn't change
230
             try {
231
                 //listen for the RINGING response
232
                 responseCollector.collectResponseEvent();
233
             } catch (TooManyListenersException ex) {
234
                 throw new TckInternalError(
235
                     "Failed to register a SipListener with an RI SipProvider",
236
                     ex);
237
             }
238
             try {
239
                 tran.sendResponse(ringing);
240
             } catch (SipException ex) {
241
                 ex.printStackTrace();
242
                 fail("The TI failed to send a RINGING response");
243
             }
244
             //The Transaction should still be PROCEEDING
245
             assertEquals(
246
                 "The Transaction did not remain PROCEEDING after transmitting a RINGING response",
247
                 .,
248
                 tran.getState());
249
            
250
           //Check whether the RINGING is received by the RI.
251
             waitForMessage();
252
 
253
             responseEvent = responseCollector.extractCollectedResponseEvent();
254
             assertNotNull(
255
                 "The RINGING response was not received by the RI",
256
                 responseEvent);
257
             assertTrue(
258
                 "A response different from RINGING was sent by the TI",
259
                 .
260
                     == responseEvent.getResponse().getStatusCode());
261
             //Resend the INVITE, see that it is hidden from the TU and see that
262
             //the _RINGING_ response is resent (and not the TRYING)
263
             try {
264
                 //listen for the Trying response
265
                 responseCollector.collectResponseEvent();
266
             } catch (TooManyListenersException ex) {
267
                 throw new TckInternalError(
268
                     "Failed to register a SipListener with an RI SipProvider",
269
                     ex);
270
             }
271
             try {
272
                 .collectRequestEvent();
273
                 .sendRequest(invite);
274
             } catch (SipException ex) {
275
                 throw new TckInternalError(
276
                     "A SipExceptionOccurred while trying to send request!",
277
                     ex);
278
             } catch (TooManyListenersException ex) {
279
                 throw new TiUnexpectedError(
280
                     "Failed to register a SipListener with a TI SipProvider",
281
                     ex);
282
             }
283
             //Wait for the INVITE
284
             waitForMessage();
285
             inviteReceivedEvent = .extractCollectedRequestEvent();
286
             assertNull(
287
                 "Retransmitted INVITEs should not be passed to the TU",
288
                 inviteReceivedEvent);
289
             //Wait for a retransmitted RINGING response
290
             waitForMessage();
291
             //Verify whether there was a RINGING response
292
             responseEvent = responseCollector.extractCollectedResponseEvent();
293
             assertNotNull(
294
                 "No RINGING response has been sent by the TI upon reception "
295
                     + "of an INVITE request",
296
                 responseEvent);
297
             assertTrue(
298
                 "A response different from RINGING was sent by the TI upon "
299
                     + "reception of a retransmitted invite INVITE",
300
                 .
301
                     == responseEvent.getResponse().getStatusCode());
302
             //We should still be proceeding
303
             assertEquals(
304
                 "The server transaction left the PROCEEDING state.",
305
                 .,
306
                 tran.getState());
307
             //Send 300 - 699 from TU and see the tran goes COMPLETED
308
             Response busy = null;
309
             try {
310
                 busy =
311
                     .createResponse(
312
                         .,
313
                         tran.getRequest());
314
                 addStatus(tran.getRequest(), busy);
315
             } catch (ParseException ex) {
316
                 throw new TiUnexpectedError(
317
                     "A ParseException was thrown while trying to create a busy_here "
318
                         + "response using TI",
319
                     ex);
320
             }
321
             try {
322
                 //listen for the BUSY_HERE response
323
                 responseCollector.collectResponseEvent();
324
             } catch (TooManyListenersException ex) {
325
                 throw new TckInternalError(
326
                     "Failed to register a SipListener with an RI SipProvider",
327
                     ex);
328
             }
329
             try {
330
                 tran.sendResponse(busy);
331
             } catch (SipException ex) {
332
                 ex.printStackTrace();
333
                 fail("The TI failed to send a BUSY_HERE response");
334
             }
335
             //The Transaction should now be COMPLETED
336
             assertEquals(
337
                 "The Transaction did not remain COMPLETED after transmitting a BUSY_HERE response",
338
                 .,
339
                 tran.getState());
340
             //Check whether the BUSY_HERE is received by the RI.
341
             waitForMessage();
342
             responseEvent = responseCollector.extractCollectedResponseEvent();
343
             assertNotNull(
344
                 "The BUSY_HERE response was not received by the RI",
345
                 responseEvent);
346
             assertTrue(
347
                 "A response different from BUSY_HERE was sent by the TI",
348
                 .
349
                     == responseEvent.getResponse().getStatusCode());
350
             //Resend the initial from INVITE from the RI and see that TI
351
             //resends the 300 - 699 (see that tran state remains COMPLETED)
352
             try {
353
                 //listen for the Trying response
354
                 responseCollector.collectResponseEvent();
355
             } catch (TooManyListenersException ex) {
356
                 throw new TckInternalError(
357
                     "Failed to register a SipListener with an RI SipProvider",
358
                     ex);
359
             }
360
             try {
361
                 .collectRequestEvent();
362
                 .sendRequest(invite);
363
             } catch (SipException ex) {
364
                 throw new TckInternalError(
365
                     "A SipExceptionOccurred while trying to send request!",
366
                     ex);
367
             } catch (TooManyListenersException ex) {
368
                 throw new TiUnexpectedError(
369
                     "Failed to register a SipListener with a TI SipProvider",
370
                     ex);
371
             }
372
             //Wait for the INVITE
373
             waitForMessage();
374
             inviteReceivedEvent = .extractCollectedRequestEvent();
375
             assertNull(
376
                 "Retransmitted INVITEs should not be passed to the TU",
377
                 inviteReceivedEvent);
378
             //Wait for a retransmitted BUSY_HERE response
379
             waitForMessage();
380
             //Verify whether there was a BUSY_HERE response
381
             responseEvent = responseCollector.extractCollectedResponseEvent();
382
             assertNotNull(
383
                 "No BUSY_HERE response has been sent by the TI upon reception "
384
                     + "of a retransmitted INVITE request",
385
                 responseEvent);
386
             assertTrue(
387
                 "A response different from BUSY_HERE was sent by the TI upon "
388
                     + "reception of a retransmitted invite INVITE",
389
                 .
390
                     == responseEvent.getResponse().getStatusCode());
391
             //We should still be COMPLETED
392
             assertEquals(
393
                 "The server transaction left the COMPLETED state.",
394
                 .,
395
                 tran.getState());
396
             //Send an ack from the RI and see that the tran goes CONFIRMED
397
             //and that response retransmissions cease
398
             Request ack = (Request) invite.clone();
399
             try {
400
                 .collectRequestEvent();
401
                 ack.setMethod(.);
402
 
403
                 // JvB: to tag must match response!
404
                 String toTag = ((ToHeader) responseEvent.getResponse().getHeader("to")).getTag();
405
                 if (toTag!=null) {
406
                     ((ToHeader) ack.getHeader("to")).setTag( toTag );
407
                 }
408
 
409
                 .sendRequest(ack);
410
             } catch (TooManyListenersException ex) {
411
                 throw new TiUnexpectedError(
412
                     "Failed to register a SipListener with the TI provider",
413
                     ex);
414
             } catch (Exception ex) {
415
                 throw new TckInternalError(
416
                     "Failed to create an ack request",
417
                     ex);
418
             }
419
             waitForMessage();
420
             RequestEvent ackEvent =
421
                 .extractCollectedRequestEvent();
422
 
423
             assertNull(
424
                 "ACKs in ServerInviteTransactions shouldn't be passed to the TU.",
425
                 ackEvent);
426
             assertEquals(
427
                 "The ServerTransaction did not pas into the confirmed state"
428
                     + "after receiving an ACK.",
429
                 .,
430
                 tran.getState());
431
         } catch (Throwable exc) {
432
             exc.printStackTrace();
433
             fail(exc.getClass().getName() + ": " + exc.getMessage());
434
         }
435
         assertTrue(new Exception().getStackTrace()[0].toString(), true);
436
 
437
     }

    
JvB: tests CANCEL for an INVITE ST 
441
 
442
     public void testCanceledInvite() {
443
         try {
444
             Request invite = createRiInviteRequest(null, null, null);
445
             SipEventCollector responseCollector = new SipEventCollector();
446
             //Before Sending the request we should first register a listener with the
447
             //RI that would catch the TRYING response
448
             try {
449
                 responseCollector.collectResponseEvent();
450
             } catch (TooManyListenersException ex) {
451
                 throw new TckInternalError(
452
                     "Failed to register a SipListener with an RI SipProvider",
453
                     ex);
454
             }
455
             //Send the initial request (JvB: using a CT)
456
             ClientTransaction riInviteCt;
457
             try {
458
                 .collectRequestEvent();
459
                 riInviteCt = .getNewClientTransaction( invite );
460
                 riInviteCt.sendRequest();
461
             } catch (SipException ex) {
462
                 throw new TckInternalError(
463
                     "A SipExceptionOccurred while trying to send request!",
464
                     ex);
465
             } catch (TooManyListenersException ex) {
466
                 throw new TiUnexpectedError(
467
                     "Failed to register a SipListener with a TI SipProvider",
468
                     ex);
469
             }
470
             waitForMessage();
471
             RequestEvent inviteReceivedEvent =
472
                 .extractCollectedRequestEvent();
473
             if (inviteReceivedEvent == null
474
                 || inviteReceivedEvent.getRequest() == null)
475
                 throw new TiUnexpectedError("The initial invite request was not received by the TI!");
476
             //Let's create the transaction
477
             ServerTransaction tran = null;
478
             try {
479
                 tran =
480
                     .getNewServerTransaction(
481
                         inviteReceivedEvent.getRequest());
482
             } catch (Exception ex) {
483
                 ex.printStackTrace();
484
                 fail(
485
                     ex.getClass().getName()
486
                         + "was thrown while trying to "
487
                         + "create the server transaction");
488
             }
489
             assertNotNull(
490
                 "tiSipProvider.getNewServerTransaction() returned null",
491
                 tran);
492
             //Check whether a TRYING response has been sent.
493
             //wait for the trying response
494
             waitForMessage();
495
             // At this point state must be PROCEEDING
496
             assertEquals(., tran.getState());
497
             ResponseEvent responseEvent =
498
                 responseCollector.extractCollectedResponseEvent();
499
             assertNotNull(
500
                 "No TRYING response has been sent by the TI upon reception "
501
                     + "of an INVITE request",
502
                 responseEvent);
503
             assertTrue(
504
                 "A response different from 100 was sent by the TI upon "
505
                     + "reception of INVITE",
506
                 . == responseEvent.getResponse().getStatusCode());
507
 
508
             //Create & send RINGING. See that it is properly sent
509
             //and that tran state doesn't change
510
             Response ringing = null;
511
             try {
512
                 ringing =
513
                     .createResponse(
514
                         .,
515
                         tran.getRequest());
516
                 ((ToHeader) ringing.getHeader(.)).setTag(
517
                     Integer.toString(hashCode()));
518
                 addStatus(tran.getRequest(), ringing);
519
                 // BUG report from Ben Evans:
520
                 // set contact header on dialog-creating response
521
                 ringing.setHeader(createTiContact());
522
             } catch (ParseException ex) {
523
                 throw new TiUnexpectedError(
524
                     "A ParseException was thrown while trying to create a ringing "
525
                         + "response using TI",
526
                     ex);
527
             }
528
             try {
529
                 //listen for the RINGING response
530
                 responseCollector.collectResponseEvent();
531
             } catch (TooManyListenersException ex) {
532
                 throw new TckInternalError(
533
                     "Failed to register a SipListener with an RI SipProvider",
534
                     ex);
535
             }
536
             try {
537
                 tran.sendResponse(ringing);
538
             } catch (SipException ex) {
539
                 ex.printStackTrace();
540
                 fail("The TI failed to send a RINGING response");
541
             }
542
             //The Transaction should still be PROCEEDING
543
             assertEquals(
544
                 "The Transaction did not remain PROCEEDING after transmitting a RINGING response",
545
                 .,
546
                 tran.getState());
547
             //Check whether the RINGING is received by the RI.
548
             waitForMessage();
549
             responseEvent = responseCollector.extractCollectedResponseEvent();
550
             assertNotNull(
551
                 "The RINGING response was not received by the RI",
552
                 responseEvent);
553
             assertTrue(
554
                 "A response different from RINGING was sent by the TI",
555
                 .
556
                     == responseEvent.getResponse().getStatusCode());
557
 
558
             // JvB: *new* : send CANCEL here
559
             Request riCancel = riInviteCt.createCancel();
560
 
561
             // Send the CANCEL request
562
             try {
563
                 .collectRequestEvent();
564
                 .sendRequest(riCancel);
565
             } catch (SipException ex) {
566
                 throw new TckInternalError(
567
                     "A SipExceptionOccurred while trying to send CANCEL request!",
568
                     ex);
569
             } catch (TooManyListenersException ex) {
570
                 throw new TiUnexpectedError(
571
                     "Failed to register a SipListener with a TI SipProvider",
572
                     ex);
573
             }
574
             waitForMessage();
575
             RequestEvent cancelReceivedEvent = .extractCollectedRequestEvent();
576
             if (cancelReceivedEvent == null
577
                 || cancelReceivedEvent.getRequest() == null)
578
                 throw new TiUnexpectedError("The CANCEL request was not received by the TI!");
579
 
580
             // Check that a ST was matched, and that it is equal to the INVITE ST branch.
581
             assertEquals( tran.getBranchId(), cancelReceivedEvent.getServerTransaction().getBranchId() );
582
 
583
             // Send an OK to the CANCEL
584
             Response cancelOK;
585
             try {
586
                 cancelOK =
587
                     .createResponse(
588
                         ., cancelReceivedEvent.getRequest() );
589
                 addStatus( cancelReceivedEvent.getRequest(), cancelOK );
590
             } catch (ParseException ex) {
591
                 throw new TiUnexpectedError(
592
                     "A ParseException was thrown while trying to create a OK "
593
                         + "response using TI",
594
                     ex);
595
             }
596
             try {
597
                 //listen for the OK response
598
                 responseCollector.collectResponseEvent();
599
             } catch (TooManyListenersException ex) {
600
                 throw new TckInternalError(
601
                     "Failed to register a SipListener with an RI SipProvider",
602
                     ex);
603
             }
604
             try {
605
                 cancelReceivedEvent.getServerTransaction().sendResponse(cancelOK);
606
             } catch (SipException ex) {
607
                 ex.printStackTrace();
608
                 fail("The TI failed to send a CANCEL OK response");
609
             }
610
 
611
             // Check whether the OK is received by the RI.
612
             waitForMessage();
613
             responseEvent = responseCollector.extractCollectedResponseEvent();
614
             assertNotNull(
615
                 "The CANCEL OK response was not received by the RI",
616
                 responseEvent);
617
             assertTrue(
618
                 "A response different from OK was sent by the TI",
619
                 .
620
                     == responseEvent.getResponse().getStatusCode());
621
 
622
             //Send 487 from TU and see the tran goes COMPLETED
623
             Response reqTerminated = null;
624
             try {
625
                 reqTerminated =
626
                     .createResponse(
627
                         .,
628
                         tran.getRequest());
629
                 addStatus(tran.getRequest(), reqTerminated);
630
             } catch (ParseException ex) {
631
                 throw new TiUnexpectedError(
632
                     "A ParseException was thrown while trying to create a req_terminated "
633
                         + "response using TI",
634
                     ex);
635
             }
636
             try {
637
                 //listen for the BUSY_HERE response
638
                 responseCollector.collectResponseEvent();
639
             } catch (TooManyListenersException ex) {
640
                 throw new TckInternalError(
641
                     "Failed to register a SipListener with an RI SipProvider",
642
                     ex);
643
             }
644
             try {
645
                 tran.sendResponse( reqTerminated );
646
             } catch (SipException ex) {
647
                 ex.printStackTrace();
648
                 fail("The TI failed to send a REQUEST_TERMINATED response");
649
             }
650
             //The Transaction should now be COMPLETED
651
             assertEquals(
652
                 "The Transaction did not remain COMPLETED after transmitting a REQUEST_TERMINATED response",
653
                 .,
654
                 tran.getState());
655
             //Check whether the BUSY_HERE is received by the RI.
656
             waitForMessage();
657
             responseEvent = responseCollector.extractCollectedResponseEvent();
658
             assertNotNull(
659
                 "The REQUEST_TERMINATED response was not received by the RI",
660
                 responseEvent);
661
             assertEquals(
662
                 "A response different from REQUEST_TERMINATED was sent by the TI",
663
                 ., responseEvent.getResponse().getStatusCode() );
664
 
665
             // RI CT should have sent ACK, tran should be in CONFIRMED
666
             // and response retransmissions should cease
667
             assertEquals(
668
                 "The ServerTransaction did not pas into the confirmed state"
669
                     + "after receiving an ACK.",
670
                 ., tran.getState());
671
         } catch (Throwable exc) {
672
             exc.printStackTrace();
673
             fail(exc.getClass().getName() + ": " + exc.getMessage());
674
         }
675
         assertTrue(new Exception().getStackTrace()[0].toString(), true);
676
 
677
     }

    
JvB: tests CANCEL for an INVITE ST, from an non-RFC3261 client which uses a Via branch not starting with the magic cookie 
682
 
683
     public void testNonRFC3261CanceledInvite() {
684
         try {
685
             Request invite = createRiInviteRequest(null, null, null);
686
 
687
             // JvB: Pretend it is sent by an older client
688
             ViaHeader topVia = (ViaHeader) invite.getHeader( "Via" );
689
             topVia.setBranch( "non-rfc3261" );
690
 
691
             SipEventCollector responseCollector = new SipEventCollector();
692
             //Before Sending the request we should first register a listener with the
693
             //RI that would catch the TRYING response
694
             try {
695
                 responseCollector.collectResponseEvent();
696
             } catch (TooManyListenersException ex) {
697
                 throw new TckInternalError(
698
                     "Failed to register a SipListener with an RI SipProvider",
699
                     ex);
700
             }
701
             //Send the initial request (JvB: using a CT)
702
             ClientTransaction riInviteCt;
703
             try {
704
                 .collectRequestEvent();
705
                 riInviteCt = .getNewClientTransaction( invite );
706
                 riInviteCt.sendRequest();
707
             } catch (SipException ex) {
708
                 throw new TckInternalError(
709
                     "A SipExceptionOccurred while trying to send request!",
710
                     ex);
711
             } catch (TooManyListenersException ex) {
712
                 throw new TiUnexpectedError(
713
                     "Failed to register a SipListener with a TI SipProvider",
714
                     ex);
715
             }
716
             waitForMessage();
717
             RequestEvent inviteReceivedEvent =
718
                 .extractCollectedRequestEvent();
719
             if (inviteReceivedEvent == null
720
                 || inviteReceivedEvent.getRequest() == null)
721
                 throw new TiUnexpectedError("The initial invite request was not received by the TI!");
722
             //Let's create the transaction
723
             ServerTransaction tran = null;
724
             try {
725
                 tran =
726
                     .getNewServerTransaction(
727
                         inviteReceivedEvent.getRequest());
728
             } catch (Exception ex) {
729
                 ex.printStackTrace();
730
                 fail(
731
                     ex.getClass().getName()
732
                         + "was thrown while trying to "
733
                         + "create the server transaction");
734
             }
735
             assertNotNull(
736
                 "tiSipProvider.getNewServerTransaction() returned null",
737
                 tran);
738
             //Check whether a TRYING response has been sent.
739
             //wait for the trying response
740
             waitForMessage();
741
             // At this point state must be PROCEEDING
742
             assertEquals(., tran.getState());
743
             ResponseEvent responseEvent =
744
                 responseCollector.extractCollectedResponseEvent();
745
             assertNotNull(
746
                 "No TRYING response has been sent by the TI upon reception "
747
                     + "of an INVITE request",
748
                 responseEvent);
749
             assertTrue(
750
                 "A response different from 100 was sent by the TI upon "
751
                     + "reception of INVITE",
752
                 . == responseEvent.getResponse().getStatusCode());
753
 
754
             //Create & send RINGING. See that it is properly sent
755
             //and that tran state doesn't change
756
             Response ringing = null;
757
             try {
758
                 ringing =
759
                     .createResponse(
760
                         .,
761
                         tran.getRequest());
762
                 ((ToHeader) ringing.getHeader(.)).setTag(
763
                     Integer.toString(hashCode()));
764
                 addStatus(tran.getRequest(), ringing);
765
                 // BUG report from Ben Evans:
766
                 // set contact header on dialog-creating response
767
                 ringing.setHeader(createTiContact());
768
             } catch (ParseException ex) {
769
                 throw new TiUnexpectedError(
770
                     "A ParseException was thrown while trying to create a ringing "
771
                         + "response using TI",
772
                     ex);
773
             }
774
             try {
775
                 //listen for the RINGING response
776
                 responseCollector.collectResponseEvent();
777
             } catch (TooManyListenersException ex) {
778
                 throw new TckInternalError(
779
                     "Failed to register a SipListener with an RI SipProvider",
780
                     ex);
781
             }
782
             try {
783
                 tran.sendResponse(ringing);
784
             } catch (SipException ex) {
785
                 ex.printStackTrace();
786
                 fail("The TI failed to send a RINGING response");
787
             }
788
             //The Transaction should still be PROCEEDING
789
             assertEquals(
790
                 "The Transaction did not remain PROCEEDING after transmitting a RINGING response",
791
                 .,
792
                 tran.getState());
793
             //Check whether the RINGING is received by the RI.
794
             waitForMessage();
795
             responseEvent = responseCollector.extractCollectedResponseEvent();
796
             assertNotNull(
797
                 "The RINGING response was not received by the RI",
798
                 responseEvent);
799
             assertTrue(
800
                 "A response different from RINGING was sent by the TI",
801
                 .
802
                     == responseEvent.getResponse().getStatusCode());
803
 
804
             // JvB: *new* : send CANCEL here
805
             Request riCancel = riInviteCt.createCancel();
806
 
807
             // Send the CANCEL request
808
             try {
809
                 .collectRequestEvent();
810
                 .sendRequest(riCancel);
811
             } catch (SipException ex) {
812
                 throw new TckInternalError(
813
                     "A SipExceptionOccurred while trying to send CANCEL request!",
814
                     ex);
815
             } catch (TooManyListenersException ex) {
816
                 throw new TiUnexpectedError(
817
                     "Failed to register a SipListener with a TI SipProvider",
818
                     ex);
819
             }
820
             waitForMessage();
821
             RequestEvent cancelReceivedEvent = .extractCollectedRequestEvent();
822
             if (cancelReceivedEvent == null
823
                 || cancelReceivedEvent.getRequest() == null)
824
                 throw new TiUnexpectedError("The CANCEL request was not received by the TI!");
825
 
826
             // Check that a ST was matched, and that it is equal to the INVITE ST
827
             assertEquals( tran.getBranchId(), cancelReceivedEvent.getServerTransaction().getBranchId() );
828
 
829
             // Send an OK to the CANCEL
830
             Response cancelOK;
831
             try {
832
                 cancelOK =
833
                     .createResponse(
834
                         ., cancelReceivedEvent.getRequest() );
835
                 addStatus( cancelReceivedEvent.getRequest(), cancelOK );
836
             } catch (ParseException ex) {
837
                 throw new TiUnexpectedError(
838
                     "A ParseException was thrown while trying to create a OK "
839
                         + "response using TI",
840
                     ex);
841
             }
842
             try {
843
                 //listen for the OK response
844
                 responseCollector.collectResponseEvent();
845
             } catch (TooManyListenersException ex) {
846
                 throw new TckInternalError(
847
                     "Failed to register a SipListener with an RI SipProvider",
848
                     ex);
849
             }
850
             try {
851
                 // send it statelessly
852
                 cancelReceivedEvent.getServerTransaction().sendResponse(cancelOK);
853
             } catch (SipException ex) {
854
                 ex.printStackTrace();
855
                 fail("The TI failed to send a CANCEL OK response");
856
             }
857
 
858
             // Check whether the OK is received by the RI.
859
             waitForMessage();
860
             responseEvent = responseCollector.extractCollectedResponseEvent();
861
             assertNotNull(
862
                 "The CANCEL OK response was not received by the RI",
863
                 responseEvent);
864
             assertTrue(
865
                 "A response different from OK was sent by the TI",
866
                 .
867
                     == responseEvent.getResponse().getStatusCode());
868
 
869
             //Send 487 from TU and see the tran goes COMPLETED
870
             Response reqTerminated = null;
871
             try {
872
                 reqTerminated =
873
                     .createResponse(
874
                         .,
875
                         tran.getRequest());
876
                 addStatus(tran.getRequest(), reqTerminated);
877
             } catch (ParseException ex) {
878
                 throw new TiUnexpectedError(
879
                     "A ParseException was thrown while trying to create a req_terminated "
880
                         + "response using TI",
881
                     ex);
882
             }
883
             try {
884
                 //listen for the BUSY_HERE response
885
                 responseCollector.collectResponseEvent();
886
             } catch (TooManyListenersException ex) {
887
                 throw new TckInternalError(
888
                     "Failed to register a SipListener with an RI SipProvider",
889
                     ex);
890
             }
891
             try {
892
                 tran.sendResponse( reqTerminated );
893
             } catch (SipException ex) {
894
                 ex.printStackTrace();
895
                 fail("The TI failed to send a REQUEST_TERMINATED response");
896
             }
897
             //The Transaction should now be COMPLETED
898
             assertEquals(
899
                 "The Transaction did not remain COMPLETED after transmitting a REQUEST_TERMINATED response",
900
                 .,
901
                 tran.getState());
902
             //Check whether the BUSY_HERE is received by the RI.
903
             waitForMessage();
904
             responseEvent = responseCollector.extractCollectedResponseEvent();
905
             assertNotNull(
906
                 "The REQUEST_TERMINATED response was not received by the RI",
907
                 responseEvent);
908
             assertTrue(
909
                 "A response different from REQUEST_TERMINATED was sent by the TI",
910
                 .
911
                     == responseEvent.getResponse().getStatusCode());
912
 
913
             // RI CT should have sent ACK, tran should be in CONFIRMED
914
             // and response retransmissions should cease
915
             assertEquals(
916
                 "The ServerTransaction did not pas into the confirmed state"
917
                     + "after receiving an ACK.",
918
                 ., tran.getState());
919
         } catch (Throwable exc) {
920
             exc.printStackTrace();
921
             fail(exc.getClass().getName() + ": " + exc.getMessage());
922
         }
923
         assertTrue(new Exception().getStackTrace()[0].toString(), true);
924
 
925
     }

    
JvB: tests CANCEL for an INVITE ST, in case the client changes the case of the branch id to all lowercvase (NIST used to do this) 
930
 
931
     public void testCaseInsensitiveCanceledInvite() {
932
         try {
933
             Request invite = createRiInviteRequest(null, null, null);
934
             SipEventCollector responseCollector = new SipEventCollector();
935
             //Before Sending the request we should first register a listener with the
936
             //RI that would catch the TRYING response
937
             try {
938
                 responseCollector.collectResponseEvent();
939
             } catch (TooManyListenersException ex) {
940
                 throw new TckInternalError(
941
                     "Failed to register a SipListener with an RI SipProvider",
942
                     ex);
943
             }
944
             //Send the initial request (JvB: using a CT)
945
             ClientTransaction riInviteCt;
946
             try {
947
                 .collectRequestEvent();
948
                 riInviteCt = .getNewClientTransaction( invite );
949
                 riInviteCt.sendRequest();
950
             } catch (SipException ex) {
951
                 throw new TckInternalError(
952
                     "A SipExceptionOccurred while trying to send request!",
953
                     ex);
954
             } catch (TooManyListenersException ex) {
955
                 throw new TiUnexpectedError(
956
                     "Failed to register a SipListener with a TI SipProvider",
957
                     ex);
958
             }
959
             waitForMessage();
960
             RequestEvent inviteReceivedEvent =
961
                 .extractCollectedRequestEvent();
962
             if (inviteReceivedEvent == null
963
                 || inviteReceivedEvent.getRequest() == null)
964
                 throw new TiUnexpectedError("The initial invite request was not received by the TI!");
965
             //Let's create the transaction
966
             ServerTransaction tran = null;
967
             try {
968
                 tran =
969
                     .getNewServerTransaction(
970
                         inviteReceivedEvent.getRequest());
971
             } catch (Exception ex) {
972
                 ex.printStackTrace();
973
                 fail(
974
                     ex.getClass().getName()
975
                         + "was thrown while trying to "
976
                         + "create the server transaction");
977
             }
978
             assertNotNull(
979
                 "tiSipProvider.getNewServerTransaction() returned null",
980
                 tran);
981
             //Check whether a TRYING response has been sent.
982
             //wait for the trying response
983
             waitForMessage();
984
             // At this point state must be PROCEEDING
985
             assertEquals(., tran.getState());
986
             ResponseEvent responseEvent =
987
                 responseCollector.extractCollectedResponseEvent();
988
             assertNotNull(
989
                 "No TRYING response has been sent by the TI upon reception "
990
                     + "of an INVITE request",
991
                 responseEvent);
992
             assertTrue(
993
                 "A response different from 100 was sent by the TI upon "
994
                     + "reception of INVITE",
995
                 . == responseEvent.getResponse().getStatusCode());
996
 
997
             //Create & send RINGING. See that it is properly sent
998
             //and that tran state doesn't change
999
             Response ringing = null;
1000
            try {
1001
                ringing =
1002
                    .createResponse(
1003
                        .,
1004
                        tran.getRequest());
1005
                ((ToHeader) ringing.getHeader(.)).setTag(
1006
                    Integer.toString(hashCode()));
1007
                addStatus(tran.getRequest(), ringing);
1008
                // BUG report from Ben Evans:
1009
                // set contact header on dialog-creating response
1010
                ringing.setHeader(createTiContact());
1011
            } catch (ParseException ex) {
1012
                throw new TiUnexpectedError(
1013
                    "A ParseException was thrown while trying to create a ringing "
1014
                        + "response using TI",
1015
                    ex);
1016
            }
1017
            try {
1018
                //listen for the RINGING response
1019
                responseCollector.collectResponseEvent();
1020
            } catch (TooManyListenersException ex) {
1021
                throw new TckInternalError(
1022
                    "Failed to register a SipListener with an RI SipProvider",
1023
                    ex);
1024
            }
1025
            try {
1026
                tran.sendResponse(ringing);
1027
            } catch (SipException ex) {
1028
                ex.printStackTrace();
1029
                fail("The TI failed to send a RINGING response");
1030
            }
1031
            //The Transaction should still be PROCEEDING
1032
            assertEquals(
1033
                "The Transaction did not remain PROCEEDING after transmitting a RINGING response",
1034
                .,
1035
                tran.getState());
1036
            //Check whether the RINGING is received by the RI.
1037
            waitForMessage();
1038
            responseEvent = responseCollector.extractCollectedResponseEvent();
1039
            assertNotNull(
1040
                "The RINGING response was not received by the RI",
1041
                responseEvent);
1042
            assertTrue(
1043
                "A response different from RINGING was sent by the TI",
1044
                .
1045
                    == responseEvent.getResponse().getStatusCode());
1047
            // JvB: *new* : send CANCEL here
1048
            Request riCancel = riInviteCt.createCancel();
1050
            // Change Via branch to all lower case, clients SHOULD NOT
1051
            // do this but stack should be able to handle this
1052
            ViaHeader topVia = (ViaHeader) riCancel.getHeader("Via");
1053
            topVia.setBranch( topVia.getBranch().toLowerCase() );
1055
            // Send the CANCEL request
1056
            try {
1057
                .collectRequestEvent();
1058
                .sendRequest(riCancel);
1059
            } catch (SipException ex) {
1060
                throw new TckInternalError(
1061
                    "A SipExceptionOccurred while trying to send CANCEL request!",
1062
                    ex);
1063
            } catch (TooManyListenersException ex) {
1064
                throw new TiUnexpectedError(
1065
                    "Failed to register a SipListener with a TI SipProvider",
1066
                    ex);
1067
            }
1068
            waitForMessage();
1069
            RequestEvent cancelReceivedEvent = .extractCollectedRequestEvent();
1070
            if (cancelReceivedEvent == null
1071
                || cancelReceivedEvent.getRequest() == null)
1072
                throw new TiUnexpectedError("The CANCEL request was not received by the TI!");
1074
            // Check that a ST was matched, and that it is equal to the INVITE ST
1075
            // mranga -- I dont know if its valid to do things this way!
1076
            //assertSame( tran, cancelReceivedEvent.getServerTransaction() );
1078
            // Send an OK to the CANCEL
1079
            Response cancelOK;
1080
            try {
1081
                cancelOK =
1082
                    .createResponse(
1083
                        ., cancelReceivedEvent.getRequest() );
1084
                addStatus( cancelReceivedEvent.getRequest(), cancelOK );
1085
            } catch (ParseException ex) {
1086
                throw new TiUnexpectedError(
1087
                    "A ParseException was thrown while trying to create a OK "
1088
                        + "response using TI",
1089
                    ex);
1090
            }
1091
            try {
1092
                //listen for the OK response
1093
                responseCollector.collectResponseEvent();
1094
            } catch (TooManyListenersException ex) {
1095
                throw new TckInternalError(
1096
                    "Failed to register a SipListener with an RI SipProvider",
1097
                    ex);
1098
            }
1099
            try {
1101
                cancelReceivedEvent.getServerTransaction().sendResponse(cancelOK);
1102
            } catch (SipException ex) {
1103
                ex.printStackTrace();
1104
                fail("The TI failed to send a CANCEL OK response");
1105
            }
1107
            // Check whether the OK is received by the RI.
1108
            waitForMessage();
1109
            responseEvent = responseCollector.extractCollectedResponseEvent();
1110
            assertNotNull(
1111
                "The CANCEL OK response was not received by the RI",
1112
                responseEvent);
1113
            assertTrue(
1114
                "A response different from OK was sent by the TI",
1115
                .
1116
                    == responseEvent.getResponse().getStatusCode());
1118
            //Send 487 from TU and see the tran goes COMPLETED
1119
            Response reqTerminated = null;
1120
            try {
1121
                reqTerminated =
1122
                    .createResponse(
1123
                        .,
1124
                        tran.getRequest());
1125
                addStatus(tran.getRequest(), reqTerminated);
1126
            } catch (ParseException ex) {
1127
                throw new TiUnexpectedError(
1128
                    "A ParseException was thrown while trying to create a req_terminated "