testptpdispatch.java

java开源的企业总线.xmlBlaster

   /** 12 messages are sent */
   private void noQueuingOverflow(boolean isPersistent, String msgPrefix) {
      boolean forceQueuing = false;
      boolean shutdownCb = true;
      prepare(shutdownCb);
      
      doPublish(0 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(0 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      // allow one overflow but now an exception should come ...
      doPublish(0 , forceQueuing, true, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      // ... and again just to make sure ...
      doPublish(0 , forceQueuing, true, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);

      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      
      doPublish(2 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(2 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(2 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(2 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);

      // TODO add the tests on subject queue overflow here (configure subject queue first)
      //doPublish(-1, forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT);
      //doPublish(-1, forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT);
      //doPublish(-1, forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT);
      //doPublish(-1, forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT);

      cleanup();
   }

   /**
    * TEST: <br />
    */
   public void testNoQueuingOverflowTransient() {
      noQueuingOverflow(false, "NoQueuingOverflowTransient");
   }

   /**
    * TEST: <br />
    */
   public void testNoQueuingOverflowPersistent() {
      noQueuingOverflow(true, "NoQueuingOverflowPersistent");
   }

// -----------------------------------------------------------------------
   /** 5 messages are sent */
   private void queuingNoOverflow(boolean isPersistent, String msgPrefix) {
      boolean forceQueuing = true;
      boolean shutdownCb = false;
      
      prepare(shutdownCb); // creates session TestPtPDispatch/1 und TestPtPDispatch/2
      
      // doPublish(int destNum, boolean forceQueuing, boolean expectEx, int[] counts, long timeout, boolean persistent, String contentPrefix)
      doPublish(-1, forceQueuing, false, new int[] {1,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(0 , forceQueuing, false, new int[] {1,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(2 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix); // session TestPtPDispatch/3 will be dynamically created
      doPublish(3 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix); // session TestPtPDispatch/4 will be dynamically created

      // checkWithoutPublish(PtPDestination dest, boolean wantsPtP, int expected, long delay)
      checkWithoutPublish(this.destinations[2], true, 1, TIMEOUT);
      checkWithoutPublish(this.destinations[3], false,0, TIMEOUT); // wantsPtP==false is too late as doPublish(3,...) dynamically created one with default settings      // TODO check for dead letters. There should be one here  

      cleanup();
   }

   /**
    * TEST: <br />
    */
   public void testQueuingNoOverflowTransient() {
      queuingNoOverflow(false, "QueuingNoOverflowTransient");
   }
   
   /**
    * TEST: <br />
    */
   public void testQueuingNoOverflowPersistent() {
      queuingNoOverflow(true, "QueuingNoOverflowPersistent");
   }
   
// -----------------------------------------------------------------------
   /** 12 messages are sent */
   private void queuingOverflow(boolean isPersistent, String msgPrefix) {
      boolean forceQueuing = true;
      boolean shutdownCb = true;
      prepare(shutdownCb);
      doPublish(0 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(0 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(0 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(0 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);

      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(1 , forceQueuing, true , new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
   
      checkWithReconnect(0, true, 2, TIMEOUT);
   
      // this should not throw an exception since default queue configuration 
      // which allows many entries
      //doPublish(2 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      //doPublish(2 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      //doPublish(2 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      //doPublish(2 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);

      //doPublish(-1, forceQueuing, false, new int[] {1,0,0,0}, TIMEOUT);

      //checkForUnknown(this.destinations[2], true, 1, TIMEOUT);
      //checkForUnknown(this.destinations[3], false,0, TIMEOUT);
      // TODO check for dead letters. There should be one here  

      cleanup();
   }

   public void testQueuingOverflowTransient() {
      queuingOverflow(false, "QueuingOverflowTransient");
   }
   
   public void testQueuingOverflowPersistent() {
      queuingOverflow(true, "QueuingOverflowPersistent");
   }
   
// -----------------------------------------------------------------------

   private void subjectQueueNoOverflow(boolean isPersistent, String msgPrefix) {
      boolean forceQueuing = false;
      boolean shutdownCb = false;
      prepare(shutdownCb);
      
      doPublish(-1 , forceQueuing, false, new int[] {1,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, false, new int[] {1,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      cleanup();
   }

   public void testSubjectQueueNoOverflowTransient() {
      subjectQueueNoOverflow(false, "SubjectQueueNoOverflowTransient");
   }
   
   public void testSubjectQueueNoOverflowPersistent() {
      subjectQueueNoOverflow(true, "SubjectQueueNoOverflowPersistent");
   }
   
// ------------------------------------------------------------------------

   private void subjectQueueOverflow(boolean isPersistent, String msgPrefix) {
      boolean shutdownCb = true;
      prepare(shutdownCb);
      
      boolean forceQueuing = false;
      doPublish(-1 , forceQueuing, true, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);

      forceQueuing = true;
      doPublish(-1 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, false, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, true, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      doPublish(-1 , forceQueuing, true, new int[] {0,0,0,0}, TIMEOUT, isPersistent, msgPrefix);
      cleanup();
   }

   public void testSubjectQueueOverflowTransient() {
      subjectQueueNoOverflow(false, "SubjectQueueNoOverflowTransient");
   }
   
   public void testSubjectQueueOverflowPersistent() {
      subjectQueueNoOverflow(true, "SubjectQueueNoOverflowPersistent");
   }
   
// -----------------------------------------------------------------------

   /**
    * Invoke: java org.xmlBlaster.test.client.TestPtPDispatch
    * <p />
    * @deprecated Use the TestRunner from the testsuite to run it:<p />
    * <pre>   java -Djava.compiler= junit.textui.TestRunner org.xmlBlaster.test.client.TestPtPDispatch</pre>
    */
   public static void main(String args[]) {
      Global glob = new Global();
      if (glob.init(args) != 0) {
         System.out.println(ME + ": Init failed");
         System.exit(1);
      }

      TestPtPDispatch testSub = new TestPtPDispatch(glob, "TestPtPDispatch");

      testSub.setUp();
      testSub.testNoQueuingNoOverflowPersistent();
      testSub.tearDown();

      testSub.setUp();
      testSub.testNoQueuingNoOverflowTransient();
      testSub.tearDown();

      testSub.setUp();
      testSub.testQueuingNoOverflowPersistent();
      testSub.tearDown();
      
      testSub.setUp();
      testSub.testQueuingNoOverflowTransient();
      testSub.tearDown();

      testSub.setUp();
      testSub.testNoQueuingOverflowPersistent();
      testSub.tearDown();
      
      testSub.setUp();
      testSub.testNoQueuingOverflowTransient();
      testSub.tearDown();

      testSub.setUp();
      testSub.testQueuingOverflowPersistent();
      testSub.tearDown();
      
      testSub.setUp();
      testSub.testQueuingOverflowTransient();
      testSub.tearDown();

      testSub.setUp();
      testSub.testSubjectQueueNoOverflowPersistent();
      testSub.tearDown();

      testSub.setUp();
      testSub.testSubjectQueueNoOverflowTransient();
      testSub.tearDown();
      
      testSub.setUp();
      testSub.testSubjectQueueOverflowPersistent();
      testSub.tearDown();

      testSub.setUp();
      testSub.testSubjectQueueOverflowTransient();
      testSub.tearDown();
      
   }
}