package com.notuvy.singleapp;
   
   import com.notuvy.singleapp.multiuser.MultiUserFixture;
   import com.notuvy.singleapp.multiuser.MultiUserSingleAppEnforcer;
   import org.apache.commons.lang.StringUtils;
   import org.junit.*;
   
   import java.io.Serializable;
   import java.util.concurrent.atomic.AtomicInteger;
  
  /**
   * User: murali
   * Date: 7/6/12
   * Time: 7:08 PM
   * To change this template use File | Settings | File Templates.
   */
  public class TestSingletonApplicationLauncher {
  
      //------------------------------------------------------------
      //- Class Variables
  
      static {
          System.setProperty("log4j.configuration", "singleapp_log4j.xml");
      }
  
      private static final int PORT = 48382;
  
  
      //------------------------------------------------------------
      //- Class Functions
  
  
      //------------------------------------------------------------
      //- Instance Variables
  
      String message = "Uninitialized";
      private static final MultiUserFixture fixture = new MultiUserFixture();
  
  
      //------------------------------------------------------------
      //- Fixtures
  
      abstract class App {
          final String fIdentifier;
          String fFromPreempt = "";
          final AtomicInteger fFlag = new AtomicInteger(0);
  
          App(String pIdentifier) {
              fIdentifier = pIdentifier;
          }
  
          public void run() {
              message = fIdentifier;
              if (StringUtils.isNotBlank(fFromPreempt)) {
                  message = message + fFromPreempt;
              }
          }
  
          @Override
          public String toString() {
              return String.format("App[%s]", fIdentifier);
          }
  
          void waitForDefer() {
              int value = fFlag.decrementAndGet();
              // MultiUserSingleAppEnforcer.LOG.info("wait flag: " + value);
              while (value != 0) {
                  try {
                      Thread.sleep(50);
                  } catch (InterruptedException e) {
                      // Ignore.
                  }
                  value = fFlag.intValue();
              }
          }
      }
  
      class DeferApp extends App implements Deferable {
          DeferApp(String pIdentifier) {
              super(pIdentifier);
          }
  
          public Serializable sendFromDeferred() {
              return fIdentifier;
          }
  
          public void recvFromDeferred(Object pObject) {
              message = message + String.format(", (deferred %s)", pObject);
              fFlag.incrementAndGet();
          }
  
      }
  
      class PreemptApp extends App implements Preemptable {
          PreemptApp(String pIdentifier) {
              super(pIdentifier);
          }
  
          public Serializable sendToPreemptor() {
             return fIdentifier;
         }
 
         public void recvFromPreempted(Object pObject) {
             fFromPreempt = String.format(", (preempting %s)", pObject);
         }
 
         public void gracefulExitForPreempt() {
         }
     }
 
     @Before
     public void initialize() {
         message = "Initial";
     }
 
     @After
     public void stopCurrentRegulator() {
         fixture.terminate();
 
         System.setProperty(MultiUserSingleAppEnforcer.TEST_USER_NAME, "");
     }
 
     @BeforeClass
     public static void setupThis() {
         // Just in case there was a crash, terminate any zombie.
         fixture.terminate();
     }
 
 
     //------------------------------------------------------------
     //- Test Cases
 
 //    @Ignore
     @Test
     public void testDeferSameUser() throws InterruptedException {
         Assert.assertEquals("Initial", message);
 
         DeferApp app1 = new DeferApp("one");
         SingletonApplicationLauncher first = SingletonApplicationLauncher.onPort(PORT).setSingleUser();
         first.launchDefer(app1);
         Assert.assertEquals("one", message);
 
         SingletonApplicationLauncher.onPort(PORT).setSingleUser().launchDefer(new DeferApp("two"));
         app1.waitForDefer();
         Assert.assertEquals("one, (deferred two)", message);
 
         SingletonApplicationLauncher.onPort(PORT).setSingleUser().launchDefer(new DeferApp("three"));
         app1.waitForDefer();
         Assert.assertEquals("one, (deferred two), (deferred three)", message);
 
         first.shutdown();  // This could cause a single "Socket closed" exception.  Not a problem.  Listener gets interrupted.
     }
 
     @Test
     public void testDeferDifferentUser() throws InterruptedException {
         Assert.assertEquals("Initial", message);
 
         SingletonApplicationLauncher.onPort(PORT).launchDefer(new DeferApp("one"));
         Assert.assertEquals("one", message);
 
         System.setProperty(MultiUserSingleAppEnforcer.TEST_USER_NAME, "johndoe");
         DeferApp app4 = new DeferApp("four");
         SingletonApplicationLauncher.onPort(PORT).launchDefer(app4);
         Thread.sleep(100);
         Assert.assertEquals("four", message);
 
         SingletonApplicationLauncher.onPort(PORT).launchDefer(new DeferApp("five"));
         app4.waitForDefer();
         Assert.assertEquals("four, (deferred five)", message);
     }
 
 //    @Ignore
     @Test
     public void testPreemptSameUser() {
         Assert.assertEquals("Initial", message);
 
         SingletonApplicationLauncher.onPort(PORT).setSingleUser().setAllowSystemExit(false).setAllowSystemExit(false).launchPreempt(new PreemptApp("one"));
         Assert.assertEquals("one", message);
 
         SingletonApplicationLauncher.onPort(PORT).setSingleUser().setAllowSystemExit(false).setAllowSystemExit(false).launchPreempt(new PreemptApp("two"));
         Assert.assertEquals("two, (preempting one)", message);
 
         SingletonApplicationLauncher last = SingletonApplicationLauncher.onPort(PORT).setSingleUser().setAllowSystemExit(false).setAllowSystemExit(false);
         last.launchPreempt(new PreemptApp("three"));
         Assert.assertEquals("three, (preempting two)", message);
 
         last.shutdown();
     }
 
     @Test
     public void testPreemptDifferentUser() {
         Assert.assertEquals("Initial", message);
 
         SingletonApplicationLauncher.onPort(PORT).setAllowSystemExit(false).launchPreempt(new PreemptApp("one"));
         Assert.assertEquals("one", message);
 
         System.setProperty(MultiUserSingleAppEnforcer.TEST_USER_NAME, "johndoe");
         SingletonApplicationLauncher.onPort(PORT).setAllowSystemExit(false).launchPreempt(new PreemptApp("two"));
         Assert.assertEquals("two", message);
 
         SingletonApplicationLauncher.onPort(PORT).setAllowSystemExit(false).launchPreempt(new PreemptApp("three"));
         Assert.assertEquals("three, (preempting two)", message);
 
         SingletonApplicationLauncher.onPort(PORT).setAllowSystemExit(false).launchPreempt(new PreemptApp("four"));
         Assert.assertEquals("four, (preempting three)", message);
     }
 
 
 }