@View(id = "test.xhtml", pageBeans = @PageBean(clazz = ExampleBean.class)) // this view will be accessed and the beans will be installed
@Dependency.List({
    @Dependency(groupId = "javax.el", artifactId = "el-api", version = "2.2"), // for special dependencies
    @Dependency(StandardDependency.EL_API_2_2) // for standard dependencies
})
@RunWith(WebappTestRunner.class)
public class ExampleTestCase extends WebappTestCase
{
    
    @Inject
    private ExampleBean exampleBean; // specified as PageBean, thus it is a valid resource
    // NOTE that this ExampleBean instance will have to be a cglib proxy of the real bean class
    // in order to allow the expected method call testing
    
    public void testApplyInputValue()
    {
        // START first phase of test case: validating the view that "only" has been rendered
        // NOTE that facesContext and root are from the first (=rendering) request at this time
        assertNotNull(root.findComponent("fieldId"));
        // END first phase
        
        // START second phase of test case: setting values and clicking some button or link
        input("test value").into("fieldId"); // set values using the clientId
        click("buttonId");  // execute some action
        // END second phase
        
        // START third phase of test case: verifying the postback
        // NOTE that facesContext and root are from the second (=postback) request at this time
        assertThat(facesContext.getExternalContext().getRequestParameterMap().get("formId:fieldId")).is("test value");
        assertThat(exampleBean.getInput()).is("test value").before(PhaseId.INVOKE_APPLICATION);
        expectCall(exampleBean.action()).in(PhaseId.INVOKE_APPLICATION);
        // for void methods:
        exampleBean.actionListener(null);
        expectLastCall().in(PhaseId.INVOKE_APPLICATION);
        // END third phase
        
        // now we could again set some input and click some button or link and do some other assertions...
    }
    
}

public abstract class WebappTestCase
{
    
    protected FacesContext facesContext; // will be set appropriately before test execution
    protected UIViewRoot root; // will be set appropriately before test execution
    // TODO maybe introduce a Page object which contains the current UIViewRoot
    // and some more information (like the HTML).
    
    private List<Dependency> _dependencies = new ArrayList<Dependency>();
    
    public List<Dependency> getDependencies()
    {
        return Collections.unmodifiableList(_dependencies);
    }
    
    // TODO should only happen once for the whole test class
    protected void setUpWebapp() throws Exception 
    {
        // get all configuration (from local annotations + super-class annotations
        // to allow preconfigured Test super classes)
        Class<?> clazz = getClass();
        do
        {
            // single Dependency
            Dependency dependency = clazz.getAnnotation(Dependency.class);
            if (dependency != null)
            {
                _dependencies.add(dependency);
            }
            
            // aggregated Dependencies
            Dependency.List dependencies = clazz.getAnnotation(Dependency.List.class);
            if (dependencies != null)
            {
                _dependencies.addAll(Arrays.asList(dependencies.value()));
            }
        } 
        while ((clazz = clazz.getSuperclass()) != WebappTestCase.class);
    }
    
    // TODO should only happen once for the whole test class 
    protected void tearDownWebapp() throws Exception
    {
        _dependencies = null;
    }
    
    /*--------------------------------------------------------------
      Begin methods, that interact like the user would do
     ---------------------------------------------------------------*/
    
    /**
     * Inputs the given value in the field specified by the into() method. 
     * Typical usage: input("value").into("field-client-id");
     */
    public Input input(String value)
    {
        return new Input(value);
    }
    
    /**
     * Clicks the UICommand component with the given clientId
     * @param clientId
     */
    public void click(String clientId)
    {
        // TODO
    }
    
    /*--------------------------------------------------------------
      Begin methods, that verify expected behavior or values
     ---------------------------------------------------------------*/
    
    public final <T> Assertable<T> assertThat(T injectedMethodCall)
    {
        return new Assertable<T>(injectedMethodCall);
    }
    
    public final Call expectCall(Object methodCall)
    {
        // TODO record call
        return new Call();
    }
    
    public final Call expectLastCall()
    {
        // TODO record call
        return new Call();
    }
    
    /*--------------------------------------------------------------
      Begin classes needed for fluent API
     ---------------------------------------------------------------*/
    
    public final class Assertable<T>
    {
        
        private T _injectedMethodCall;
        private T _expectedValue;
        private PhaseAware _phaseAware;
     
        public Assertable(final T injectedMethodCall)
        {
            _injectedMethodCall = injectedMethodCall;
            // somehowe find out what method has been called on the injected resource
            // (most certainly by using cglib-proxies)
        }
        
        public PhaseAware is(final T expectedValue)
        {
            _expectedValue = expectedValue;
            _phaseAware = new PhaseAware();
            
            return _phaseAware;
        }
        
        // has to be called in the right phase by the test
        private boolean doAssert()
        {
            return _expectedValue == _injectedMethodCall 
                    || (_expectedValue != null 
                            && _expectedValue.equals(_injectedMethodCall));
        }
        
    }
    
    public final class PhaseAware
    {
        
        private boolean _after;
        private PhaseId _phase;
        
        public void after(PhaseId phase)
        {
            _after = true;
            _phase = phase;
        }
        
        public void before(PhaseId phase)
        {
            _after = false;
            _phase = phase;
        }
        
    }
    
    public final class Input
    {
        
        private String _input;
        
        public Input(String input)
        {
            _input = input;
        }
        
        public void into(String clientId)
        {
            // TODO input data into component
        }
        
    }
    
    public final class Call
    {
        
        private PhaseId _phase;
        
        public Call()
        {
            // TODO find out which method (most certainly by using cglib-proxies)
        }
        
        public void in(PhaseId phase)
        {
            _phase = phase;
        }
        
    }
    
}

@Dependency(groupId = "org.apache.myfaces", artifactId = "myfaces-extension", version = "1.0.0")
public abstract class ExtensionTestCase extends WebappTestCase
{

    // in this way we can provide preconfigured superclasses for extension tests
    
}

@View(id = "test.xhtml", pageBeans = @PageBean(clazz = ExampleBean.class)) // this view will be accessed and the beans will be installed
@Configuration(SomeConfiguration.class) // the configuration class contains the Dependencies
@RunWith(WebappTestRunner.class)
public class ExampleTestCase
{
    
    @Inject
    private ExampleBean exampleBean; // specified as PageBean, thus it is a valid resource
    // NOTE that this ExampleBean instance will have to be a cglib proxy of the real bean class
    // in order to allow the expected method call testing

    @Inject
    private WebappTester tester; // will provide all necessary methods to control the test case
    
    public void testApplyInputValue()
    {
        // START first phase of test case: validating the view that "only" has been rendered
        // NOTE that facesContext and root are from the first (=rendering) request at this time
        tester.assertNotNull(root.findComponent("fieldId"));
        // END first phase
        
        // START second phase of test case: setting values and clicking some button or link
        tester.input("test value").into("fieldId"); // set values using the clientId
        tester.click("buttonId");  // execute some action
        // END second phase
        
        // START third phase of test case: verifying the postback
        // NOTE that facesContext and root are from the second (=postback) request at this time
        tester.assertThat(facesContext.getExternalContext().getRequestParameterMap().get("formId:fieldId")).is("test value");
        tester.assertThat(exampleBean.getInput()).is("test value").before(PhaseId.INVOKE_APPLICATION);
        tester.expectCall(exampleBean.action()).in(PhaseId.INVOKE_APPLICATION);
        // for void methods:
        exampleBean.actionListener(null);
        tester.expectLastCall().in(PhaseId.INVOKE_APPLICATION);
        // END third phase
        
        // now we could again set some input and click some button or link and do some other assertions...
    }
    
}

@ConfigurationTestSuite(testSuite = AllMyFacesTests.class,
  testConfigurations = {MyFacesJettyConfig.class, MyFacesTomcatConfig.class, MyFacesEmbeddedGlassfishConfig.class})
public class AllTestsWithCommonConfigs extends ConfigurationTest
{
}