/*
* Copyright (c) 2002-2009 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.kernel.impl.event;
import java.util.ArrayList;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.neo4j.kernel.impl.event.Event;
import org.neo4j.kernel.impl.event.EventData;
import org.neo4j.kernel.impl.event.EventListenerAlreadyRegisteredException;
import org.neo4j.kernel.impl.event.EventListenerNotRegisteredException;
import org.neo4j.kernel.impl.event.EventManager;
import org.neo4j.kernel.impl.event.EventModule;
import org.neo4j.kernel.impl.event.ProActiveEventListener;
import org.neo4j.kernel.impl.event.ReActiveEventListener;
public class TestEventManager extends TestCase
{
private EventManager evtMgr;
private EventModule module = new EventModule();
public void setUp()
{
module.init();
module.start();
evtMgr = module.getEventManager();
}
public void tearDown()
{
module.stop();
module.destroy();
}
private class MyProActiveEventListener implements ProActiveEventListener
{
private boolean state = true;
public boolean proActiveEventReceived( Event event, EventData data )
{
return state;
}
void setState( boolean mode )
{
state = mode;
}
}
private class MyReActiveEventListener implements ReActiveEventListener
{
private boolean eventReceived = false;
private Thread originatingThread = null;
public void reActiveEventReceived( Event event, EventData data )
{
this.eventReceived = true;
this.originatingThread = data.getOriginatingThread();
}
void reset()
{
this.eventReceived = false;
this.originatingThread = null;
}
boolean isEventReceived()
{
return this.eventReceived;
}
Thread getOriginatingThread()
{
return this.originatingThread;
}
}
public TestEventManager( String testName )
{
super( testName );
}
public static Test suite()
{
return new TestSuite( TestEventManager.class );
}
public void testProActiveEventListener()
throws EventListenerAlreadyRegisteredException,
EventListenerNotRegisteredException
{
// register test
try
{
evtMgr.registerProActiveEventListener( null, Event.TEST_EVENT );
fail( "null listener should throw exception." );
}
catch ( EventListenerNotRegisteredException e )
{
}
MyProActiveEventListener myEvtListener1 = new MyProActiveEventListener();
try
{
evtMgr.registerProActiveEventListener( myEvtListener1, null );
fail( "null event should throw exception." );
}
catch ( EventListenerNotRegisteredException e )
{
}
evtMgr
.registerProActiveEventListener( myEvtListener1, Event.TEST_EVENT );
try
{
evtMgr.registerProActiveEventListener( myEvtListener1,
Event.TEST_EVENT );
fail( "registration of same listener, should throw exception. " );
}
catch ( EventListenerAlreadyRegisteredException e )
{
}
// unregister test
MyProActiveEventListener myEvtListener2 = new MyProActiveEventListener();
MyProActiveEventListener myEvtListener3 = new MyProActiveEventListener();
evtMgr
.registerProActiveEventListener( myEvtListener2, Event.TEST_EVENT );
evtMgr
.registerProActiveEventListener( myEvtListener3, Event.TEST_EVENT );
evtMgr.unregisterProActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
try
{
evtMgr.unregisterProActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
fail( "unregister of non registered listener "
+ "should throw exception" );
}
catch ( EventListenerNotRegisteredException e )
{
}
evtMgr
.registerProActiveEventListener( myEvtListener3, Event.TEST_EVENT );
// send test
assertTrue( evtMgr.generateProActiveEvent( Event.TEST_EVENT,
new EventData( null ) ) );
myEvtListener3.setState( false );
assertTrue( !evtMgr.generateProActiveEvent( Event.TEST_EVENT,
new EventData( null ) ) );
myEvtListener2.setState( false );
myEvtListener3.setState( true );
assertTrue( !evtMgr.generateProActiveEvent( Event.TEST_EVENT,
new EventData( null ) ) );
myEvtListener2.setState( true );
assertTrue( evtMgr.generateProActiveEvent( Event.TEST_EVENT,
new EventData( null ) ) );
evtMgr.unregisterProActiveEventListener( myEvtListener1,
Event.TEST_EVENT );
evtMgr.unregisterProActiveEventListener( myEvtListener2,
Event.TEST_EVENT );
evtMgr.unregisterProActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
assertTrue( evtMgr.generateProActiveEvent( Event.TEST_EVENT,
new EventData( null ) ) );
}
public void testReActiveEventListener()
throws EventListenerAlreadyRegisteredException,
EventListenerNotRegisteredException
{
// register test
try
{
evtMgr.registerReActiveEventListener( null, Event.TEST_EVENT );
fail( "null listener should throw exception." );
}
catch ( EventListenerNotRegisteredException e )
{
}
MyReActiveEventListener myEvtListener1 = new MyReActiveEventListener();
try
{
evtMgr.registerReActiveEventListener( myEvtListener1, null );
fail( "null event should throw exception." );
}
catch ( EventListenerNotRegisteredException e )
{
}
evtMgr.registerReActiveEventListener( myEvtListener1, Event.TEST_EVENT );
try
{
evtMgr.registerReActiveEventListener( myEvtListener1,
Event.TEST_EVENT );
fail( "registration of same listener, should throw exception. " );
}
catch ( EventListenerAlreadyRegisteredException e )
{
}
// unregister test
MyReActiveEventListener myEvtListener2 = new MyReActiveEventListener();
MyReActiveEventListener myEvtListener3 = new MyReActiveEventListener();
evtMgr.registerReActiveEventListener( myEvtListener2, Event.TEST_EVENT );
evtMgr.registerReActiveEventListener( myEvtListener3, Event.TEST_EVENT );
evtMgr.unregisterReActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
try
{
evtMgr.unregisterReActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
fail( "unregister of non registered listener "
+ "should throw exception" );
}
catch ( EventListenerNotRegisteredException e )
{
}
evtMgr.registerReActiveEventListener( myEvtListener3, Event.TEST_EVENT );
// send test
evtMgr.generateReActiveEvent( Event.TEST_EVENT, new EventData( null ) );
waitForReceived( new MyReActiveEventListener[] { myEvtListener1,
myEvtListener2, myEvtListener3 } );
evtMgr.unregisterReActiveEventListener( myEvtListener1,
Event.TEST_EVENT );
evtMgr.unregisterReActiveEventListener( myEvtListener2,
Event.TEST_EVENT );
evtMgr.unregisterReActiveEventListener( myEvtListener3,
Event.TEST_EVENT );
}
public void testStartStopEventManager()
{
module.stop();
module.start();
}
private void waitForReceived( MyReActiveEventListener[] listeners )
{
ArrayList<MyReActiveEventListener> listenerList = new ArrayList<MyReActiveEventListener>();
for ( int i = 0; i < listeners.length; i++ )
{
listenerList.add( listeners[i] );
}
int iterations = 0;
while ( listenerList.size() > 0 && iterations < 10 )
{
for ( int i = 0; i < listenerList.size(); i++ )
{
MyReActiveEventListener myListener = listenerList.get( i );
if ( myListener.isEventReceived() )
{
listenerList.remove( i );
if ( listenerList.size() == 0 )
{
return;
}
}
}
try
{
Thread.sleep( 100 );
}
catch ( InterruptedException ie )
{
}
iterations++;
}
fail( "Reactive events not received." );
}
public void testEventData()
{
Object data = new Object();
EventData eventData = new EventData( data );
assertTrue( eventData.getData() == data );
}
public void testReActiveEventOriginatingThread()
{
try
{
MyReActiveEventListener listener = new MyReActiveEventListener();
evtMgr.registerReActiveEventListener( listener, Event.TEST_EVENT );
evtMgr.generateReActiveEvent( Event.TEST_EVENT,
new EventData( null ) );
waitForReceived( new MyReActiveEventListener[] { listener } );
assertEquals( "Wrong originating thread for event", Thread
.currentThread(), listener.getOriginatingThread() );
}
catch ( Exception e )
{
fail( "Unknown exception: " + e );
}
}
}