/*
    * Created on 19/Jan/04
    *
    * To change the template for this generated file go to
    * Window>Preferences>Java>Code Generation>Code and Comments
    */
   package replica.group.jgroups;
   
   import java.util.Iterator;
  import java.util.List;
  
  import org.jgroups.Channel;
  import org.jgroups.JChannel;
  import org.jgroups.Message;
  import org.jgroups.View;
  
  import replica.group.Address;
  import replica.group.GroupManager;
  import replica.group.event.GroupListener;
  import replica.group.event.MessageEvent;
  import replica.group.event.SuspectEvent;
  import replica.group.event.ViewEvent;
  
  import junit.framework.TestCase;
  
  /***
   * @author no119431
   *
   * To change the template for this generated type comment go to
   * Window>Preferences>Java>Code Generation>Code and Comments
   */
  public class JGroupsGroupManagerTest extends TestCase {
  	
  	boolean receivedViewChangedEvent;
  	boolean receivedMessage;
  	
  	int numberReceivedViewChangedEvents;
  
  	String props=
  			"UDP(mcast_addr=228.8.8.8;mcast_port=45566;ip_ttl=32;" +
  			"mcast_send_buf_size=150000;mcast_recv_buf_size=80000):" +
  			"PING(timeout=2000;num_initial_members=3):" +
  			"MERGE2(min_interval=5000;max_interval=10000):" +
  			"FD_SOCK:" +
  			"VERIFY_SUSPECT(timeout=1500):" +
  			"pbcast.NAKACK(gc_lag=50;retransmit_timeout=600,1200,2400,4800):" +
  			"UNICAST(timeout=600,1200,2400):" +
  			"pbcast.STABLE(desired_avg_gossip=20000):" +
  			"FRAG(frag_size=4096;down_thread=false;up_thread=false):" +
  			"pbcast.GMS(join_timeout=5000;join_retry_timeout=2000;" +
  			"shun=true;print_local_addr=false)";
  			
      /***
       * Constructor for JGroupsGroupManagerTest.
       * @param arg0
       */
      public JGroupsGroupManagerTest(String arg0) {
          super(arg0);
      }
  
      public void testAddListener() {
  		JGroupsGroupManager man = new JGroupsGroupManager();
  		
  		GroupListener listen = getNewGroupListener();
  		
  		man.addListener( listen );
  		
  		assertNotNull( man.groupListeneres );
  		assertEquals( 1,man.groupListeneres.size());
  		assertEquals( listen, man.groupListeneres.get(0) );    	
      }
  
      public void testJoinGroupWith1Member() {
      	
      	String groupName = "testGroup";
      	
      	Channel channel = getChannel();
      	JGroupsGroupManager manager = getNewConnectedManager( channel, groupName);
      	
      	List view = manager.getGroupView();
      	
      	assertNotNull( view );
      	assertEquals(1, view.size() );
      	
      	channel.close();
      }
      
  	public void testJoinGroupWith2Members() {
  		
  		String groupName = "testGroup";
      	
      	Channel channel1 = getChannel();
  		JGroupsGroupManager coord = getNewConnectedManager( channel1, groupName);
      	
  		View view1 = channel1.getView();
      	
  		assertNotNull( view1 );
  		assertEquals(1, view1.size() );
  		
 		Channel channel2 = getChannel();
 		JGroupsGroupManager other = getNewConnectedManager( channel2, groupName);
     	
 		View view2 = channel2.getView();
     	
 		assertNotNull( view2 );
 		assertEquals(2, view2.size() );
 		
 		channel1.close();
 		channel2.close();
 	}
 	
 	/***
 	 * Tests connect-disconnect-connect sequence for a group with two members
 	 **/
 	public void testDisconnectConnectTwo() throws Exception {
 		View     view;
 		Channel coordinator = getChannel();
 		coordinator.connect("testgroup");
 		view=coordinator.getView();
 		System.out.println("-- view for coordinator: " + view);
 
 		Channel channel = getChannel();
 		channel.connect("testgroup1");
 		view=channel.getView();
 		System.out.println("-- view for channel: " + view);
 
 		channel.disconnect();
 
 		channel.connect("testgroup");
 		view=channel.getView();
 		System.out.println("-- view for channel: " + view);
 
 		assertEquals(2, view.size());
 		assertTrue(view.containsMember(channel.getLocalAddress()));
 		assertTrue(view.containsMember(coordinator.getLocalAddress()));
 		coordinator.close();
 	}
 	
     public void testLeaveGroup() {
     	
     	Channel channel = getChannel();
     	
     	JGroupsGroupManager man = getNewConnectedManager(channel, "testGroup");
     	
     	assertTrue( channel.isConnected() );
     	
     	man.leaveGroup();
     	
     	assertFalse( channel.isConnected() );
     }
 
     /*
      * Test for void sendMessage(Address, Object)
      */
     public void testSendMessageAddressObject() {
     	
 		// sends one message from coordinator and other group member
 		// verify that is received
 		sendMessageObject( true, false );
     	
 		// sends one message from other group member and coordinator
 		// verify that is received
 		sendMessageObject( false, false );
     }
 
     /*
      * Test for void sendMessage(Object)
      */
     public void testSendMessageObject() {
     	
     	// sends one message from coordinator and other group member
     	// verify that is received
     	sendMessageObject( true );
     	
 		// sends one message from other group member and coordinator
 		// verify that is received
     	sendMessageObject( false );
     }
 
 	/*
 	 * Sends a message to group.
 	 * @see #sendMessageObject(boolean , boolean )
 	 */
 	protected void sendMessageObject(boolean coordToOther) {
 		sendMessageObject(coordToOther, true);
 	}
 		
 	/*
 	 * Test for void sendMessage(Object)
 	 * @param coordToOther if true the message is send from coordinator and
 	 * 			other member group verify that is received.
 	 * 				otherwise, other mamber group sends message and coordinator
 	 * 			verify that is received.
 	 * @param toGroup if true the message is sent to the group, else is
 	 * 			send to the other member only ;
 	 */
 	protected void sendMessageObject(boolean coordToOther, boolean toGroup) {
     	
 		receivedMessage = false;
     	
 		JGroupsGroupManager coordinator = null;
 		JGroupsGroupManager other = null;
 		
 		try{
 			coordinator = getNewConnectedManager(getChannel(), "testGroup");
 			other = getNewConnectedManager(getChannel(), "testGroup");
 		
 			JGroupsGroupManager sender = coordToOther ? coordinator : other;
 			JGroupsGroupManager receiver = coordToOther ? other : coordinator;
 			
 			receiver.addListener(new GroupListener(){
 				public void message(MessageEvent event){
 					System.out.println("Received {" + event + "}");
 					synchronized(JGroupsGroupManagerTest.this){
 						JGroupsGroupManagerTest.this.receivedMessage = true;
 						JGroupsGroupManagerTest.this.notify();
 					}
 				}
 				public void viewChanged(ViewEvent event){
 				}
 				public void suspect(SuspectEvent event){
 				}
 			});
 	    	
 	    	if( toGroup )
 				sender.sendMessage( new Message());
 			else
 				sender.sendMessage( receiver.getLocalAddress(), new Message() );
 	    	
 			synchronized(this){
 				if( !receivedMessage ){
 					try{
 						wait(30*1000);
 					}
 					catch(InterruptedException e){
 						throw new RuntimeException( e );
 					}
 				}
 			}
 		}
 		finally{
 			if(coordinator!=null){
 				try{
 					coordinator.getChannel().close();
 				}
 				catch(Throwable t){
 				}
 			}
 			if(coordinator!=null){
 				try{
 					other.getChannel().close();
 				}
 				catch(Throwable t){
 				}
 			}
 		}
 	}
 	
     /*
      * Test for removing a listener
      */
     public void testRemoveListener() {
     	
 		JGroupsGroupManager man = new JGroupsGroupManager();
 		
 		GroupListener listen = getNewGroupListener();
 		
 		man.addListener( listen );
 		
 		man.removeListener( listen );
 		
 		assertEquals( 0,man.groupListeneres.size());
     }
     
     /*
      * test convertViewListFromJGroups
      */
     public void testConvertViewListFromJGroups(){
     	
 		Channel managerChannel = null;
 		Channel otherChannel = null;
 		
 		try{
 			managerChannel = getChannel();
 			GroupManager manager = getNewConnectedManager(managerChannel,"testGroup");
 	    	
 	    	otherChannel = getChannel();
 	    	JGroupsGroupManager other = getNewConnectedManager(otherChannel, "testGroup");
 	    	
 	    	List myView = other.convertViewListFromJGroups( otherChannel.getView() );
 	    	
 			assertNotNull( myView );
 			
 	    	StringBuffer res = new StringBuffer();
 	    	res.append("View: {");
 	    	for (Iterator iter = myView.iterator(); iter.hasNext();) {
 	            Address element = (Address) iter.next();
 	            res.append("["+element+"] ");
 	        }
 			res.append("}.");
 			System.out.println( res );
 			
 	    	assertEquals(2, myView.size() );
 		}
 		finally{
 			if( managerChannel != null ){
 				try{
 					managerChannel.close();
 				}
 				catch(Throwable t){
 				}
 			}
 			if( otherChannel != null ){
 				try{
 					otherChannel.close();
 				}
 				catch(Throwable t){
 				}
 			}
 		}
     }
 
 	/*
 	 * Test notifyViewChanged.
 	 */
     public void testNotifyViewChanged() {
     	
 		numberReceivedViewChangedEvents = 0;
     	
 		JGroupsGroupManager coordinator = null;
 		JGroupsGroupManager other = null;
 		
 		try{
 			coordinator = new JGroupsGroupManager();
 			coordinator.addListener(new GroupListener(){
 				public void message(MessageEvent event){
 				}
 				public void viewChanged(ViewEvent event){
 					System.out.println("Received {" + event + "}");
 					synchronized(JGroupsGroupManagerTest.this){
 						JGroupsGroupManagerTest.this.numberReceivedViewChangedEvents++;
 						JGroupsGroupManagerTest.this.notify();
 					}
 				}
 				public void suspect(SuspectEvent event){
 				}
 			});
 			coordinator.setGroupName("testGroup");
 			coordinator.setChannel(getChannel());
 			coordinator.joinGroup();
 	    	
 			other = getNewConnectedManager(getChannel(), "testGroup");
 	    	
 			synchronized(this){
 				while( numberReceivedViewChangedEvents < 2 ){
 					try{
 						wait(30*1000);
 					}
 					catch(InterruptedException e){
 						throw new RuntimeException( e );
 					}
 				}
 			}
 		}
 		finally{
 			if(coordinator!=null){
 				try{
 					coordinator.getChannel().close();
 				}
 				catch(Throwable t){
 				}
 			}
 			if(coordinator!=null){
 				try{
 					other.getChannel().close();
 				}
 				catch(Throwable t){
 				}
 			}
 		}
     }
 
     public void testNotifySuspect() {
     }
     
     protected GroupListener getNewGroupListener(){
 		return new GroupListener(){
 			public void message(MessageEvent event){}
 			public void viewChanged(ViewEvent event){}
 			public void suspect(SuspectEvent event){}
 		};
     }
 
 	protected Channel getChannel(){
     	
 		JChannel channel = null;
 		try {
 			channel=new JChannel(props);
 		}
 		catch(Exception ex) {
 			// channel creation failed
 			throw new RuntimeException( ex );
 		}
 			
 		return channel;
 	}
 
 	protected JGroupsGroupManager getNewConnectedManager(Channel channel, String groupName ){
     	
 		JGroupsGroupManager manager = new JGroupsGroupManager();
     	
 		manager.setChannel( channel );
 		manager.setGroupName( groupName );
     	
 		manager.joinGroup();
 		
 		return manager;
 	}
 	
 	private void sendMessages(JGroupsGroupManager manager, int num) {
 		
 		Message msg;
 		for(int i=0; i < num; i++) {
 			try {
 				msg=new Message();
 				manager.sendMessage(msg);
 				System.out.print(i + " ");
 			}
 			catch(Throwable t) {
 				fail("could not send message #" + i);
 			}
 		}
 	}
 
 
 }