Attachment #211919 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 Frank Appel 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

 *
 * Contributors:
 *    Frank Appel - initial API and implementation
 *    EclipseSource - ongoing development
 ******************************************************************************/
package org.eclipse.rwt.internal.application;


import org.eclipse.rwt.application.ApplicationConfigurator;
import org.eclipse.rwt.internal.engine.RWTConfiguration;
import org.eclipse.rwt.internal.engine.RWTConfigurationImpl;
import org.eclipse.rwt.internal.lifecycle.CurrentPhase;
import org.eclipse.rwt.internal.service.ApplicationStoreImpl;
import org.eclipse.rwt.internal.service.ServiceManager;
import org.eclipse.rwt.internal.textsize.MeasurementListener;

  }

  private void addInternalPhaseListeners( ApplicationContext applicationContext ) {
    applicationContext.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
    applicationContext.getPhaseListenerRegistry().add( new MeasurementListener() );
  }





/*******************************************************************************
 * 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


public final class CurrentPhase {

  private static final String ATTR_CURRENT_PHASE = CurrentPhase.class.getName() + "#value";

    public void beforePhase( PhaseEvent event ) {
      set( event.getPhaseId() );
    }

    public void afterPhase( PhaseEvent event ) {
      // do nothing
    }

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

  private static final String ATTR_CURRENT_PHASE
    = CurrentPhase.class.getName() + "#value";

  private CurrentPhase() {
    // prevent instantiation




/*******************************************************************************
 * 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

    PhaseId currentPhaseId = startPhaseId;
    while( currentPhaseId != null ) {
      IPhase currentPhase = findPhase( currentPhaseId );
      CurrentPhase.set( currentPhaseId );
      phaseListenerManager.notifyBeforePhase( currentPhaseId );
      PhaseId nextPhaseId = currentPhase.execute( getDisplay() );
      phaseListenerManager.notifyAfterPhase( currentPhaseId );
      currentPhaseId = nextPhaseId;
    }
  }

  abstract Display getDisplay();

  private IPhase findPhase( PhaseId phaseId ) {

Lines 145-150 Link Here

(-)src/org/eclipse/rwt/internal/lifecycle/RWTLifeCycle.java (+1 lines)
145	boolean interrupted = false;	145	boolean interrupted = false;
146	for( int i = start; !interrupted && i < phaseOrder.length; i++ ) {	146	for( int i = start; !interrupted && i < phaseOrder.length; i++ ) {
147	IPhase phase = phaseOrder[ i ];	147	IPhase phase = phaseOrder[ i ];
		148	CurrentPhase.set( phase.getPhaseId() );
148	phaseListenerManager.notifyBeforePhase( phase.getPhaseId() );	149	phaseListenerManager.notifyBeforePhase( phase.getPhaseId() );
149	if( phase instanceof IInterruptible ) {	150	if( phase instanceof IInterruptible ) {
150	// IInterruptible phases return control to the user code, thus they don't call	151	// IInterruptible phases return control to the user code, thus they don't call

Lines 108-114 Link Here

(-)src/org/eclipse/rwt/engine/RWTServletContextListener_Test.java (-1 / +1 lines)
108		108
109	private void assertPhaseListenersAreRegistered() {	109	private void assertPhaseListenersAreRegistered() {
110	ApplicationContext applicationContext = ApplicationContextUtil.get( servletContext );	110	ApplicationContext applicationContext = ApplicationContextUtil.get( servletContext );
111	assertEquals( 3, applicationContext.getPhaseListenerRegistry().getAll().length );	111	assertEquals( 2, applicationContext.getPhaseListenerRegistry().getAll().length );
112	}	112	}
113		113
114	private void assertResourceIsRegistered() {	114	private void assertResourceIsRegistered() {

Lines 30-36 Link Here

(-)src/org/eclipse/rwt/internal/application/ApplicationContextConfigurator_Test.java (-3 / +1 lines)
30	import org.eclipse.rwt.internal.AdapterManager;	30	import org.eclipse.rwt.internal.AdapterManager;
31	import org.eclipse.rwt.internal.engine.RWTConfiguration;	31	import org.eclipse.rwt.internal.engine.RWTConfiguration;
32	import org.eclipse.rwt.internal.engine.RWTConfigurationImpl;	32	import org.eclipse.rwt.internal.engine.RWTConfigurationImpl;
33	import org.eclipse.rwt.internal.lifecycle.CurrentPhase;
34	import org.eclipse.rwt.internal.service.ServiceManager;	33	import org.eclipse.rwt.internal.service.ServiceManager;
35	import org.eclipse.rwt.internal.textsize.MeasurementListener;	34	import org.eclipse.rwt.internal.textsize.MeasurementListener;
36	import org.eclipse.rwt.internal.theme.Theme;	35	import org.eclipse.rwt.internal.theme.Theme;
Lines 320-327 Link Here
320	}	319	}
321		320
322	private void checkPhaseListenersHaveBeenAdded() {	321	private void checkPhaseListenersHaveBeenAdded() {
323	assertEquals( 3, applicationContext.getPhaseListenerRegistry().getAll().length );	322	assertEquals( 2, applicationContext.getPhaseListenerRegistry().getAll().length );
324	assertEquals( true, findPhaseListener( CurrentPhase.Listener.class ) );
325	assertEquals( true, findPhaseListener( MeasurementListener.class ) );	323	assertEquals( true, findPhaseListener( MeasurementListener.class ) );
326	assertEquals( true, findPhaseListener( TestPhaseListener.class ) );	324	assertEquals( true, findPhaseListener( TestPhaseListener.class ) );
327	}	325	}




/*******************************************************************************
 * 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 junit.framework.TestCase;

import org.eclipse.rap.rwt.testfixture.Fixture;
import org.eclipse.rap.rwt.testfixture.internal.LoggingPhaseListener;
import org.eclipse.rap.rwt.testfixture.internal.LoggingPhaseListener.PhaseEventInfo;
import org.eclipse.rwt.lifecycle.*;

      super( phaseListenerManager, phases );
    }

    @Override
    Display getDisplay() {
      return null;
    }

    public void addPhaseListener( PhaseListener listener ) {
    }
  }

  private static class TestPhase implements IPhase {

    private final List<IPhase> executionLog;
    private final PhaseId phaseId;
    private final PhaseId nextPhaseId;

    TestPhase( List<IPhase> executionLog, PhaseId phaseId, PhaseId nextPhaseId ) {
      this.executionLog = executionLog;
      this.phaseId = phaseId;


  public void testExecute() throws IOException {
    List<IPhase> executionLog = new LinkedList<IPhase>();
    IPhase[] phases = new IPhase[] {
      new TestPhase( executionLog, PhaseId.PREPARE_UI_ROOT, PhaseId.RENDER ),
      new TestPhase( executionLog, PhaseId.RENDER, null )
    };
    PhaseExecutor phaseExecutor = new TestPhaseExecutor( phaseListenerManager, phases );
    phaseExecutor.execute( PhaseId.PREPARE_UI_ROOT );

    assertSame( phases[ 0 ], executionLog.get( 0 ) );
    assertSame( phases[ 1 ], executionLog.get( 1 ) );
  }

  public void testExecuteNotifiesPhaseListener() throws IOException {
    LoggingPhaseListener phaseListener = new LoggingPhaseListener( PhaseId.ANY );
    phaseListenerManager.addPhaseListener( phaseListener );
    IPhase[] phases = new IPhase[] {
      new TestPhase( new LinkedList<IPhase>(), PhaseId.PREPARE_UI_ROOT, null ),
    };
    PhaseExecutor phaseExecutor = new TestPhaseExecutor( phaseListenerManager, phases );
    phaseExecutor.execute( PhaseId.PREPARE_UI_ROOT );

    assertSame( lifeCycle, afterPrepareUIRoot.source );
  }

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

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




/*******************************************************************************
 * 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/application/ApplicationContextConfigurator.java (-3 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2011 Frank Appel and others.	2	* Copyright (c) 2011, 2012 Frank Appel 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 7-12 Link Here
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Frank Appel - initial API and implementation	9	* Frank Appel - initial API and implementation
		10	* EclipseSource - ongoing development
10	******************************************************************************/	11	******************************************************************************/
11	package org.eclipse.rwt.internal.application;	12	package org.eclipse.rwt.internal.application;
12		13
Lines 15-21 Link Here
15	import org.eclipse.rwt.application.ApplicationConfigurator;	16	import org.eclipse.rwt.application.ApplicationConfigurator;
16	import org.eclipse.rwt.internal.engine.RWTConfiguration;	17	import org.eclipse.rwt.internal.engine.RWTConfiguration;
17	import org.eclipse.rwt.internal.engine.RWTConfigurationImpl;	18	import org.eclipse.rwt.internal.engine.RWTConfigurationImpl;
18	import org.eclipse.rwt.internal.lifecycle.CurrentPhase;
19	import org.eclipse.rwt.internal.service.ApplicationStoreImpl;	19	import org.eclipse.rwt.internal.service.ApplicationStoreImpl;
20	import org.eclipse.rwt.internal.service.ServiceManager;	20	import org.eclipse.rwt.internal.service.ServiceManager;
21	import org.eclipse.rwt.internal.textsize.MeasurementListener;	21	import org.eclipse.rwt.internal.textsize.MeasurementListener;
Lines 92-98 Link Here
92	}	92	}
93		93
94	private void addInternalPhaseListeners( ApplicationContext applicationContext ) {	94	private void addInternalPhaseListeners( ApplicationContext applicationContext ) {
95	applicationContext.getPhaseListenerRegistry().add( new CurrentPhase.Listener() );
96	applicationContext.getPhaseListenerRegistry().add( new MeasurementListener() );	95	applicationContext.getPhaseListenerRegistry().add( new MeasurementListener() );
97	}	96	}
98		97