Attachment #211881 for bug #372960

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2011, 2012 EclipseSource and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.rwt.internal.lifecycle;

import java.text.MessageFormat;
import java.util.LinkedHashSet;
import java.util.Set;

import org.eclipse.rwt.internal.service.ServletLog;

  private final ILifeCycle eventSource;
  private final Object lock;
  private final Set<PhaseListener> phaseListeners;

  PhaseListenerManager( ILifeCycle eventSource ) {
    this.eventSource = eventSource;
    this.lock = new Object();
    this.phaseListeners = new LinkedHashSet<PhaseListener>();
  }

  void addPhaseListener( PhaseListener phaseListener ) {
    ParamCheck.notNull( phaseListener, "phaseListener" );
    synchronized( lock ) {
      phaseListeners.add( phaseListener );
    }
  }

  void addPhaseListeners( PhaseListener[] phaseListeners ) {
    ParamCheck.notNull( phaseListeners, "phaseListeners" );
    for( int i = 0; i < phaseListeners.length; i++ ) {

      return result;
    }
  }

  void notifyBeforePhase( PhaseId phase ) {
    PhaseListener[] phaseListeners = getPhaseListeners();
    PhaseEvent event = new PhaseEvent( eventSource, phase );

      }
    }
  }

  private static boolean mustNotify( PhaseId phase, PhaseId listenerPhase ) {
    return listenerPhase == PhaseId.ANY || listenerPhase == phase;
  }




/*******************************************************************************
 * Copyright (c) 2002, 2012 Innoopract Informationssysteme GmbH and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 ******************************************************************************/
package org.eclipse.rwt.internal.lifecycle;

import java.util.LinkedHashSet;
import java.util.Set;

import org.eclipse.rwt.internal.util.ParamCheck;

  private final Set<PhaseListener> phaseListeners;

  public PhaseListenerRegistry() {
    phaseListeners = new LinkedHashSet<PhaseListener>();
  }

  public void add( PhaseListener listener ) {
    ParamCheck.notNull( listener, "listener" );
    phaseListeners.add( listener );
  }

  public void remove( PhaseListener listener ) {
    ParamCheck.notNull( listener, "listener" );
    phaseListeners.remove( listener );




/*******************************************************************************
 * Copyright (c) 2002, 2012 Innoopract Informationssysteme GmbH and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

  }

  private PhaseListenerRegistry phaseListenerRegistry;

  public void testAdd() {
    PhaseListener phaseListener = new TestPhaseListener();
    phaseListenerRegistry.add( phaseListener );

    } catch( NullPointerException expected ) {
    }
  }

  public void testRemove() {
    PhaseListener phaseListener = new TestPhaseListener();
    phaseListenerRegistry.add( phaseListener );
    phaseListenerRegistry.remove( phaseListener );
    assertEquals( 0, phaseListenerRegistry.getAll().length );
  }

  public void testRemoveAll() {
    PhaseListener phaseListener = new TestPhaseListener();
    phaseListenerRegistry.add( phaseListener );
    phaseListenerRegistry.removeAll();
    assertEquals( 0, phaseListenerRegistry.getAll().length );
  }

  public void testRemoveWithNullArgument() {
    try {
      phaseListenerRegistry.remove( null );

    } catch( NullPointerException expected ) {
    }
  }

  public void testListenersOrder() {
    PhaseListener phaseListener1 = new TestPhaseListener();
    PhaseListener phaseListener2 = new TestPhaseListener();
    phaseListenerRegistry.add( phaseListener1 );
    phaseListenerRegistry.add( phaseListener2 );

    PhaseListener[] allListeners = phaseListenerRegistry.getAll();

    assertSame( phaseListener1, allListeners[ 0 ] );
    assertSame( phaseListener2, allListeners[ 1 ] );
  }

  @Override
  protected void setUp() {
    phaseListenerRegistry = new PhaseListenerRegistry();
  }

  @Override
  protected void tearDown()  {
    ensureServiceContextHasBeenDisposed();
  }




/*******************************************************************************
 * Copyright (c) 2011, 2012 EclipseSource and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.rap.rwt.testfixture.*;
import org.eclipse.rap.rwt.testfixture.internal.LoggingPhaseListener;
import org.eclipse.rap.rwt.testfixture.internal.LoggingPhaseListener.PhaseEventInfo;
import org.eclipse.rwt.RWT;
import org.eclipse.rwt.internal.service.ContextProvider;
import org.eclipse.rwt.lifecycle.*;
import org.eclipse.swt.widgets.Display;


public class PhaseListenerManager_Test extends TestCase {

  private static class TestError extends Error {
    private static final long serialVersionUID = 1L;
  }


  private static class ErrorPhaseListener implements PhaseListener {
    private static final long serialVersionUID = 1L;

    public void beforePhase( PhaseEvent event ) {
      throw new TestError();
    }

    public void afterPhase( PhaseEvent event ) {
      throw new TestError();
    }

    public PhaseId getPhaseId() {
      return PhaseId.ANY;
    }

  private List<Throwable> exceptionsInServletLog;
  private PhaseListenerManager phaseListenerManager;
  private ILifeCycle lifeCycle;

  public void testAddPhaseListenerWithNullArgument() {
    try {
      phaseListenerManager.addPhaseListener( null );

    } catch( NullPointerException expected ) {
    }
  }

  public void testAddPhaseListener() {
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( null );
    phaseListenerManager.addPhaseListener( phaseListener );

    PhaseListener[] phaseListeners = phaseListenerManager.getPhaseListeners();
    assertEquals( 1, phaseListeners.length );
  }

  public void testAddPhaseListeners() {
    PhaseListener phaseListener1 = new EmptyPhaseListener();
    PhaseListener phaseListener2 = new EmptyPhaseListener();

    PhaseListener[] returnedPhaseListeners = phaseListenerManager.getPhaseListeners();
    assertEquals( 2, returnedPhaseListeners.length );
  }

  public void testAddPhaseListenersWithNullArgument() {
    try {
      phaseListenerManager.addPhaseListeners( null );

    } catch( NullPointerException expected ) {
    }
  }

  public void testRemovePhaseListenerWithNullArgument() {
    try {
      phaseListenerManager.removePhaseListener( null );

    PhaseListener[] phaseListeners = phaseListenerManager.getPhaseListeners();
    assertEquals( 0, phaseListeners.length );
  }

  public void testRemovePhaseListenerTwice() {
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( null );
    phaseListenerManager.addPhaseListener( phaseListener );

    PhaseListener[] phaseListeners = phaseListenerManager.getPhaseListeners();
    assertEquals( 0, phaseListeners.length );
  }

  public void testRemovePhaseListenerWithUnknownPhaseListener() {
    phaseListenerManager.addPhaseListener( new LoggingPhaseListener( null ) );
    phaseListenerManager.removePhaseListener( new LoggingPhaseListener( null ) );
    PhaseListener[] phaseListeners = phaseListenerManager.getPhaseListeners();
    assertEquals( 1, phaseListeners.length );
  }

  public void testGetPhaseListenersReturnsSafeCopy() {
    phaseListenerManager.addPhaseListener( new LoggingPhaseListener( null ) );
    PhaseListener[] phaseListeners1 = phaseListenerManager.getPhaseListeners();

    PhaseListener[] phaseListeners2 = phaseListenerManager.getPhaseListeners();
    assertNotNull( phaseListeners2[ 0 ] );
  }

  public void testAddRemovePhaseListenerConcurently() throws InterruptedException {
    final int threadCount = 120;
    final List<Thread> succeededThreads = Collections.synchronizedList( new LinkedList<Thread>() );

    phaseListenerManager.notifyBeforePhase( phase );
    assertEquals( 1, phaseListener.getLoggedEvents().length );
    PhaseEventInfo phaseEvent = phaseListener.getLoggedEvents()[ 0 ];
    assertSame( lifeCycle, phaseEvent.source );
    assertEquals( phase, phaseEvent.phaseId );
  }

  public void testNotifyBeforePhaseWithNonMatchingListener() {
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( PhaseId.RENDER );
    phaseListenerManager.addPhaseListener( phaseListener );
    phaseListenerManager.notifyBeforePhase( PhaseId.READ_DATA );
    assertEquals( 0, phaseListener.getLoggedEvents().length );
  }

  public void testNotifyBeforePhaseWithANYListener() {
    PhaseId phase = PhaseId.READ_DATA;
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( PhaseId.ANY );

    phaseListenerManager.notifyBeforePhase( phase );
    assertEquals( 1, phaseListener.getLoggedEvents().length );
    PhaseEventInfo phaseEvent = phaseListener.getLoggedEvents()[ 0 ];
    assertSame( lifeCycle, phaseEvent.source );
    assertEquals( phase, phaseEvent.phaseId );
  }

  public void testExceptionsInBeforePhaseEvent() {
    phaseListenerManager.addPhaseListener( new ExceptionPhaseListener() );
    phaseListenerManager.addPhaseListener( new ExceptionPhaseListener() );

    phaseListenerManager.addPhaseListener( phaseListener );
    phaseListenerManager.notifyAfterPhase( phase );
    assertEquals( 1, phaseListener.getLoggedEvents().length );
    assertSame( lifeCycle, phaseListener.getLoggedEvents()[ 0 ].source );
    assertEquals( phase, phaseListener.getLoggedEvents()[ 0 ].phaseId );
  }

  public void testNotifyAfterPhaseWithNonMatchingListener() {
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( PhaseId.RENDER );
    phaseListenerManager.addPhaseListener( phaseListener );
    phaseListenerManager.notifyAfterPhase( PhaseId.READ_DATA );
    assertEquals( 0, phaseListener.getLoggedEvents().length );
  }

  public void testNotifyAfterPhaseWithANYListener() {
    PhaseId phase = PhaseId.READ_DATA;
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( PhaseId.ANY );

    phaseListenerManager.notifyAfterPhase( phase );
    assertEquals( 1, phaseListener.getLoggedEvents().length );
    PhaseEventInfo phaseEvent = phaseListener.getLoggedEvents()[ 0 ];
    assertSame( lifeCycle, phaseEvent.source );
    assertEquals( phase, phaseEvent.phaseId );
  }

  public void testExceptionsInAfterPhaseEvent() {
    phaseListenerManager.addPhaseListener( new ExceptionPhaseListener() );
    phaseListenerManager.addPhaseListener( new ExceptionPhaseListener() );

    }
  }

  // see bug 372960
  public void testCurrentPhaseMatchPhaseEventPhase() {
    new Display();
    final List<PhaseId> log = new ArrayList<PhaseId>();
    RWT.getLifeCycle().addPhaseListener( new PhaseListener() {
      public PhaseId getPhaseId() {
        return PhaseId.PROCESS_ACTION;
      }
      public void beforePhase( PhaseEvent event ) {
        log.add( CurrentPhase.get() );
        log.add( event.getPhaseId() );
      }
      public void afterPhase( PhaseEvent event ) {
      }
    } );

    Fixture.executeLifeCycleFromServerThread();

    assertEquals( log.get( 0 ), log.get( 1 ) );
  }

  @Override
  protected void setUp() throws Exception {
    Fixture.setUp();
    lifeCycle = new TestLifeCycle();

    setupServletContextLog();
  }

  @Override
  protected void tearDown() throws Exception {
    Fixture.tearDown();
  }

Return to bug 372960

Lines 1-5 Link Here

(-)src/org/eclipse/rwt/internal/engine/PhaseListenerRegistry_Test.java (-7 / +21 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2002, 2011 Innoopract Informationssysteme GmbH and others.	2	* Copyright (c) 2002, 2012 Innoopract Informationssysteme GmbH and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 33-39 Link Here
33	}	33	}
34		34
35	private PhaseListenerRegistry phaseListenerRegistry;	35	private PhaseListenerRegistry phaseListenerRegistry;
36		36
37	public void testAdd() {	37	public void testAdd() {
38	PhaseListener phaseListener = new TestPhaseListener();	38	PhaseListener phaseListener = new TestPhaseListener();
39	phaseListenerRegistry.add( phaseListener );	39	phaseListenerRegistry.add( phaseListener );
Lines 46-66 Link Here
46	} catch( NullPointerException expected ) {	46	} catch( NullPointerException expected ) {
47	}	47	}
48	}	48	}
49		49
50	public void testRemove() {	50	public void testRemove() {
51	PhaseListener phaseListener = new TestPhaseListener();	51	PhaseListener phaseListener = new TestPhaseListener();
52	phaseListenerRegistry.add( phaseListener );	52	phaseListenerRegistry.add( phaseListener );
53	phaseListenerRegistry.remove( phaseListener );	53	phaseListenerRegistry.remove( phaseListener );
54	assertEquals( 0, phaseListenerRegistry.getAll().length );	54	assertEquals( 0, phaseListenerRegistry.getAll().length );
55	}	55	}
56		56
57	public void testRemoveAll() {	57	public void testRemoveAll() {
58	PhaseListener phaseListener = new TestPhaseListener();	58	PhaseListener phaseListener = new TestPhaseListener();
59	phaseListenerRegistry.add( phaseListener );	59	phaseListenerRegistry.add( phaseListener );
60	phaseListenerRegistry.removeAll();	60	phaseListenerRegistry.removeAll();
61	assertEquals( 0, phaseListenerRegistry.getAll().length );	61	assertEquals( 0, phaseListenerRegistry.getAll().length );
62	}	62	}
63		63
64	public void testRemoveWithNullArgument() {	64	public void testRemoveWithNullArgument() {
65	try {	65	try {
66	phaseListenerRegistry.remove( null );	66	phaseListenerRegistry.remove( null );
Lines 68-78 Link Here
68	} catch( NullPointerException expected ) {	68	} catch( NullPointerException expected ) {
69	}	69	}
70	}	70	}
71		71
		72	public void testListenersOrder() {
		73	PhaseListener phaseListener1 = new TestPhaseListener();
		74	PhaseListener phaseListener2 = new TestPhaseListener();
		75	phaseListenerRegistry.add( phaseListener1 );
		76	phaseListenerRegistry.add( phaseListener2 );
		77
		78	PhaseListener[] allListeners = phaseListenerRegistry.getAll();
		79
		80	assertSame( phaseListener1, allListeners[ 0 ] );
		81	assertSame( phaseListener2, allListeners[ 1 ] );
		82	}
		83
		84	@Override
72	protected void setUp() {	85	protected void setUp() {
73	phaseListenerRegistry = new PhaseListenerRegistry();	86	phaseListenerRegistry = new PhaseListenerRegistry();
74	}	87	}
75		88
		89	@Override
76	protected void tearDown() {	90	protected void tearDown() {
77	ensureServiceContextHasBeenDisposed();	91	ensureServiceContextHasBeenDisposed();
78	}	92	}

Lines 1-5 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/PhaseListenerManager.java (-8 / +8 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2011 EclipseSource and others.	2	* Copyright (c) 2011, 2012 EclipseSource and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-17 Link Here
11	package org.eclipse.rwt.internal.lifecycle;	11	package org.eclipse.rwt.internal.lifecycle;
12		12
13	import java.text.MessageFormat;	13	import java.text.MessageFormat;
14	import java.util.HashSet;	14	import java.util.LinkedHashSet;
15	import java.util.Set;	15	import java.util.Set;
16		16
17	import org.eclipse.rwt.internal.service.ServletLog;	17	import org.eclipse.rwt.internal.service.ServletLog;
Lines 24-43 Link Here
24	private final ILifeCycle eventSource;	24	private final ILifeCycle eventSource;
25	private final Object lock;	25	private final Object lock;
26	private final Set<PhaseListener> phaseListeners;	26	private final Set<PhaseListener> phaseListeners;
27		27
28	PhaseListenerManager( ILifeCycle eventSource ) {	28	PhaseListenerManager( ILifeCycle eventSource ) {
29	this.eventSource = eventSource;	29	this.eventSource = eventSource;
30	this.lock = new Object();	30	this.lock = new Object();
31	this.phaseListeners = new HashSet<PhaseListener>();	31	this.phaseListeners = new LinkedHashSet<PhaseListener>();
32	}	32	}
33		33
34	void addPhaseListener( PhaseListener phaseListener ) {	34	void addPhaseListener( PhaseListener phaseListener ) {
35	ParamCheck.notNull( phaseListener, "phaseListener" );	35	ParamCheck.notNull( phaseListener, "phaseListener" );
36	synchronized( lock ) {	36	synchronized( lock ) {
37	phaseListeners.add( phaseListener );	37	phaseListeners.add( phaseListener );
38	}	38	}
39	}	39	}
40		40
41	void addPhaseListeners( PhaseListener[] phaseListeners ) {	41	void addPhaseListeners( PhaseListener[] phaseListeners ) {
42	ParamCheck.notNull( phaseListeners, "phaseListeners" );	42	ParamCheck.notNull( phaseListeners, "phaseListeners" );
43	for( int i = 0; i < phaseListeners.length; i++ ) {	43	for( int i = 0; i < phaseListeners.length; i++ ) {
Lines 59-65 Link Here
59	return result;	59	return result;
60	}	60	}
61	}	61	}
62		62
63	void notifyBeforePhase( PhaseId phase ) {	63	void notifyBeforePhase( PhaseId phase ) {
64	PhaseListener[] phaseListeners = getPhaseListeners();	64	PhaseListener[] phaseListeners = getPhaseListeners();
65	PhaseEvent event = new PhaseEvent( eventSource, phase );	65	PhaseEvent event = new PhaseEvent( eventSource, phase );
Lines 89-95 Link Here
89	}	89	}
90	}	90	}
91	}	91	}
92		92
93	private static boolean mustNotify( PhaseId phase, PhaseId listenerPhase ) {	93	private static boolean mustNotify( PhaseId phase, PhaseId listenerPhase ) {
94	return listenerPhase == PhaseId.ANY \|\| listenerPhase == phase;	94	return listenerPhase == PhaseId.ANY \|\| listenerPhase == phase;
95	}	95	}