// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.GWT.forms.server;

import org.litesoft.ui_1_5.*;

import junit.framework.*;

public class InterceptingProxyExternalizationTest extends TestCase implements ExternalizationSupport {
    public static TestSuite suite() {
        return new TestSuite( InterceptingProxyExternalizationTest.class );
    }

    public InterceptingProxyExternalizationTest( String name ) {
        super( name );
    }

    public static void main( String[] args ) {
        junit.textui.TestRunner.run( suite() );
    }

    private static ExternalizationInterface BASE = new UnresolvedExternalization() {
        protected String LLresolveTooltip( String pKey ) {
            return LLresolve( pKey + TOOLTIP );
        }
    };

    private static InterceptingProxyExternalization PROXY1 = new InterceptingProxyExternalization( BASE );
    private static InterceptingProxyExternalization PROXY2 = new InterceptingProxyExternalization( PROXY1 );

    static {
        PROXY1.add( "p1common", "p1C", "p1CTT" );
        PROXY1.addLabel( "p1label", "p1L" );
        PROXY1.addAction( "p1action", "p1A", "p1ATT" );
        PROXY1.addInput( "p1input", "p1I", "p1ITT" );
        PROXY1.addError( "p1error", "p1E" );

        PROXY1.add( "p2common", "p2C", "p2CTT" );
        PROXY1.addLabel( "p2label", "p2L" );
        PROXY1.addAction( "p2action", "p2A", "p2ATT" );
        PROXY1.addInput( "p2input", "p2I", "p2ITT" );
        PROXY1.addError( "p2error", "p2E" );

        PROXY2.add( "p2common", "p22C", "p22CTT" );
        PROXY2.addLabel( "p2label", "p22L" );
        PROXY2.addAction( "p2action", "p22A", "p22ATT" );
        PROXY2.addInput( "p2input", "p22I", "p22ITT" );
        PROXY2.addError( "p2error", "p22E" );

        Collector c = new Collector();

        c.addCommon( "c1common", "c1C", "c1CTT" );
        c.addLabel( "c1label", "c1L" );
        c.addAction( "c1action", "c1A", "c1ATT" );
        c.addInput( "c1input", "c1I", "c1ITT" );
        c.addError( "c1error", "c1E" );

        c.addCommon( "c2common", "c2C", "c2CTT" );
        c.addLabel( "c2label", "c2L" );
        c.addAction( "c2action", "c2A", "c2ATT" );
        c.addInput( "c2input", "c2I", "c2ITT" );
        c.addError( "c2error", "c2E" );

        PROXY1.addAll( c );

        c = new Collector();

        c.addCommon( "c2common", "c22C", "c22CTT" );
        c.addLabel( "c2label", "c22L" );
        c.addAction( "c2action", "c22A", "c22ATT" );
        c.addInput( "c2input", "c22I", "c22ITT" );
        c.addError( "c2error", "c22E" );

        PROXY2.addAll( c );
    }

    public void testLabel()
            throws Exception {
        assertEquals( "[yo]", BASE.resolveLabel( "yo" ) );
        assertEquals( "[c1common]", BASE.resolveLabel( "c1common" ) );
        assertEquals( "[c1input]", BASE.resolveLabel( "c1input" ) );
        assertEquals( "[c1label]", BASE.resolveLabel( "c1label" ) );
        assertEquals( "[p1common]", BASE.resolveLabel( "p1common" ) );
        assertEquals( "[p1input]", BASE.resolveLabel( "p1input" ) );
        assertEquals( "[p1label]", BASE.resolveLabel( "p1label" ) );
        assertEquals( "[c2common]", BASE.resolveLabel( "c2common" ) );
        assertEquals( "[c2input]", BASE.resolveLabel( "c2input" ) );
        assertEquals( "[c2label]", BASE.resolveLabel( "c2label" ) );
        assertEquals( "[p2common]", BASE.resolveLabel( "p2common" ) );
        assertEquals( "[p2input]", BASE.resolveLabel( "p2input" ) );
        assertEquals( "[p2label]", BASE.resolveLabel( "p2label" ) );

        assertEquals( "[yo]", PROXY1.resolveLabel( "yo" ) );
        assertEquals( "c1C", PROXY1.resolveLabel( "c1common" ) );
        assertEquals( "c1I", PROXY1.resolveLabel( "c1input" ) );
        assertEquals( "c1L", PROXY1.resolveLabel( "c1label" ) );
        assertEquals( "p1C", PROXY1.resolveLabel( "p1common" ) );
        assertEquals( "p1I", PROXY1.resolveLabel( "p1input" ) );
        assertEquals( "p1L", PROXY1.resolveLabel( "p1label" ) );
        assertEquals( "c2C", PROXY1.resolveLabel( "c2common" ) );
        assertEquals( "c2I", PROXY1.resolveLabel( "c2input" ) );
        assertEquals( "c2L", PROXY1.resolveLabel( "c2label" ) );
        assertEquals( "p2C", PROXY1.resolveLabel( "p2common" ) );
        assertEquals( "p2I", PROXY1.resolveLabel( "p2input" ) );
        assertEquals( "p2L", PROXY1.resolveLabel( "p2label" ) );

        assertEquals( "[yo]", PROXY2.resolveLabel( "yo" ) );
        assertEquals( "c1C", PROXY2.resolveLabel( "c1common" ) );
        assertEquals( "c1I", PROXY2.resolveLabel( "c1input" ) );
        assertEquals( "c1L", PROXY2.resolveLabel( "c1label" ) );
        assertEquals( "p1C", PROXY2.resolveLabel( "p1common" ) );
        assertEquals( "p1I", PROXY2.resolveLabel( "p1input" ) );
        assertEquals( "p1L", PROXY2.resolveLabel( "p1label" ) );
        assertEquals( "c22C", PROXY2.resolveLabel( "c2common" ) );
        assertEquals( "c22I", PROXY2.resolveLabel( "c2input" ) );
        assertEquals( "c22L", PROXY2.resolveLabel( "c2label" ) );
        assertEquals( "p22C", PROXY2.resolveLabel( "p2common" ) );
        assertEquals( "p22I", PROXY2.resolveLabel( "p2input" ) );
        assertEquals( "p22L", PROXY2.resolveLabel( "p2label" ) );

        assertEquals( "[c1action]", BASE.resolveLabel( "c1action" ) ); // Action
        assertEquals( "[c2action]", BASE.resolveLabel( "c2action" ) ); // Action
        assertEquals( "[p1action]", BASE.resolveLabel( "p1action" ) ); // Action
        assertEquals( "[p2action]", BASE.resolveLabel( "p2action" ) ); // Action
        assertEquals( "[c1error]", BASE.resolveLabel( "c1error" ) ); // Error
        assertEquals( "[c2error]", BASE.resolveLabel( "c2error" ) ); // Error
        assertEquals( "[p1error]", BASE.resolveLabel( "p1error" ) ); // Error
        assertEquals( "[p2error]", BASE.resolveLabel( "p2error" ) ); // Error

        assertEquals( "[c1action]", PROXY1.resolveLabel( "c1action" ) ); // Action
        assertEquals( "[c2action]", PROXY1.resolveLabel( "c2action" ) ); // Action
        assertEquals( "[p1action]", PROXY1.resolveLabel( "p1action" ) ); // Action
        assertEquals( "[p2action]", PROXY1.resolveLabel( "p2action" ) ); // Action
        assertEquals( "[c1error]", PROXY1.resolveLabel( "c1error" ) ); // Error
        assertEquals( "[c2error]", PROXY1.resolveLabel( "c2error" ) ); // Error
        assertEquals( "[p1error]", PROXY1.resolveLabel( "p1error" ) ); // Error
        assertEquals( "[p2error]", PROXY1.resolveLabel( "p2error" ) ); // Error

        assertEquals( "[c1action]", PROXY2.resolveLabel( "c1action" ) ); // Action
        assertEquals( "[c2action]", PROXY2.resolveLabel( "c2action" ) ); // Action
        assertEquals( "[p1action]", PROXY2.resolveLabel( "p1action" ) ); // Action
        assertEquals( "[p2action]", PROXY2.resolveLabel( "p2action" ) ); // Action
        assertEquals( "[c1error]", PROXY2.resolveLabel( "c1error" ) ); // Error
        assertEquals( "[c2error]", PROXY2.resolveLabel( "c2error" ) ); // Error
        assertEquals( "[p1error]", PROXY2.resolveLabel( "p1error" ) ); // Error
        assertEquals( "[p2error]", PROXY2.resolveLabel( "p2error" ) ); // Error
    }

    public void testAction()
            throws Exception {
        assertEquals( "[yo]", BASE.resolveAction( "yo" ) );
        assertEquals( "[c1common]", BASE.resolveAction( "c1common" ) );
        assertEquals( "[c1action]", BASE.resolveAction( "c1action" ) );
        assertEquals( "[p1common]", BASE.resolveAction( "p1common" ) );
        assertEquals( "[p1action]", BASE.resolveAction( "p1action" ) );
        assertEquals( "[c2common]", BASE.resolveAction( "c2common" ) );
        assertEquals( "[c2action]", BASE.resolveAction( "c2action" ) );
        assertEquals( "[p2common]", BASE.resolveAction( "p2common" ) );
        assertEquals( "[p2action]", BASE.resolveAction( "p2action" ) );

        assertEquals( "[yo]", PROXY1.resolveAction( "yo" ) );
        assertEquals( "c1C", PROXY1.resolveAction( "c1common" ) );
        assertEquals( "c1A", PROXY1.resolveAction( "c1action" ) );
        assertEquals( "p1C", PROXY1.resolveAction( "p1common" ) );
        assertEquals( "p1A", PROXY1.resolveAction( "p1action" ) );
        assertEquals( "c2C", PROXY1.resolveAction( "c2common" ) );
        assertEquals( "c2A", PROXY1.resolveAction( "c2action" ) );
        assertEquals( "p2C", PROXY1.resolveAction( "p2common" ) );
        assertEquals( "p2A", PROXY1.resolveAction( "p2action" ) );

        assertEquals( "[yo]", PROXY2.resolveAction( "yo" ) );
        assertEquals( "c1C", PROXY2.resolveAction( "c1common" ) );
        assertEquals( "c1A", PROXY2.resolveAction( "c1action" ) );
        assertEquals( "p1C", PROXY2.resolveAction( "p1common" ) );
        assertEquals( "p1A", PROXY2.resolveAction( "p1action" ) );
        assertEquals( "c22C", PROXY2.resolveAction( "c2common" ) );
        assertEquals( "c22A", PROXY2.resolveAction( "c2action" ) );
        assertEquals( "p22C", PROXY2.resolveAction( "p2common" ) );
        assertEquals( "p22A", PROXY2.resolveAction( "p2action" ) );

        assertEquals( "[c1error]", BASE.resolveAction( "c1error" ) ); // Error
        assertEquals( "[c2error]", BASE.resolveAction( "c2error" ) ); // Error
        assertEquals( "[p1error]", BASE.resolveAction( "p1error" ) ); // Error
        assertEquals( "[p2error]", BASE.resolveAction( "p2error" ) ); // Error
        assertEquals( "[c1input]", BASE.resolveAction( "c1input" ) ); // Label
        assertEquals( "[c1label]", BASE.resolveAction( "c1label" ) ); // Label
        assertEquals( "[c2input]", BASE.resolveAction( "c2input" ) ); // Label
        assertEquals( "[c2label]", BASE.resolveAction( "c2label" ) ); // Label
        assertEquals( "[p1input]", BASE.resolveAction( "p1input" ) ); // Label
        assertEquals( "[p1label]", BASE.resolveAction( "p1label" ) ); // Label
        assertEquals( "[p2input]", BASE.resolveAction( "p2input" ) ); // Label
        assertEquals( "[p2label]", BASE.resolveAction( "p2label" ) ); // Label

        assertEquals( "[c1error]", PROXY1.resolveAction( "c1error" ) ); // Error
        assertEquals( "[c2error]", PROXY1.resolveAction( "c2error" ) ); // Error
        assertEquals( "[p1error]", PROXY1.resolveAction( "p1error" ) ); // Error
        assertEquals( "[p2error]", PROXY1.resolveAction( "p2error" ) ); // Error
        assertEquals( "[c1input]", PROXY1.resolveAction( "c1input" ) ); // Label
        assertEquals( "[c1label]", PROXY1.resolveAction( "c1label" ) ); // Label
        assertEquals( "[c2input]", PROXY1.resolveAction( "c2input" ) ); // Label
        assertEquals( "[c2label]", PROXY1.resolveAction( "c2label" ) ); // Label
        assertEquals( "[p1input]", PROXY1.resolveAction( "p1input" ) ); // Label
        assertEquals( "[p1label]", PROXY1.resolveAction( "p1label" ) ); // Label
        assertEquals( "[p2input]", PROXY1.resolveAction( "p2input" ) ); // Label
        assertEquals( "[p2label]", PROXY1.resolveAction( "p2label" ) ); // Label

        assertEquals( "[c1error]", PROXY2.resolveAction( "c1error" ) ); // Error
        assertEquals( "[c2error]", PROXY2.resolveAction( "c2error" ) ); // Error
        assertEquals( "[p1error]", PROXY2.resolveAction( "p1error" ) ); // Error
        assertEquals( "[p2error]", PROXY2.resolveAction( "p2error" ) ); // Error
        assertEquals( "[c1input]", PROXY2.resolveAction( "c1input" ) ); // Label
        assertEquals( "[c1label]", PROXY2.resolveAction( "c1label" ) ); // Label
        assertEquals( "[c2input]", PROXY2.resolveAction( "c2input" ) ); // Label
        assertEquals( "[c2label]", PROXY2.resolveAction( "c2label" ) ); // Label
        assertEquals( "[p1input]", PROXY2.resolveAction( "p1input" ) ); // Label
        assertEquals( "[p1label]", PROXY2.resolveAction( "p1label" ) ); // Label
        assertEquals( "[p2input]", PROXY2.resolveAction( "p2input" ) ); // Label
        assertEquals( "[p2label]", PROXY2.resolveAction( "p2label" ) ); // Label
    }

    public void testActionTooltip()
            throws Exception {
        assertEquals( "[yoTooltip]", BASE.resolveActionTooltip( "yo" ) );
        assertEquals( "[c1commonTooltip]", BASE.resolveActionTooltip( "c1common" ) );
        assertEquals( "[c1actionTooltip]", BASE.resolveActionTooltip( "c1action" ) );
        assertEquals( "[p1commonTooltip]", BASE.resolveActionTooltip( "p1common" ) );
        assertEquals( "[p1actionTooltip]", BASE.resolveActionTooltip( "p1action" ) );
        assertEquals( "[c2commonTooltip]", BASE.resolveActionTooltip( "c2common" ) );
        assertEquals( "[c2actionTooltip]", BASE.resolveActionTooltip( "c2action" ) );
        assertEquals( "[p2commonTooltip]", BASE.resolveActionTooltip( "p2common" ) );
        assertEquals( "[p2actionTooltip]", BASE.resolveActionTooltip( "p2action" ) );

        assertEquals( "[yoTooltip]", PROXY1.resolveActionTooltip( "yo" ) );
        assertEquals( "c1CTT", PROXY1.resolveActionTooltip( "c1common" ) );
        assertEquals( "c1ATT", PROXY1.resolveActionTooltip( "c1action" ) );
        assertEquals( "p1CTT", PROXY1.resolveActionTooltip( "p1common" ) );
        assertEquals( "p1ATT", PROXY1.resolveActionTooltip( "p1action" ) );
        assertEquals( "c2CTT", PROXY1.resolveActionTooltip( "c2common" ) );
        assertEquals( "c2ATT", PROXY1.resolveActionTooltip( "c2action" ) );
        assertEquals( "p2CTT", PROXY1.resolveActionTooltip( "p2common" ) );
        assertEquals( "p2ATT", PROXY1.resolveActionTooltip( "p2action" ) );

        assertEquals( "[yoTooltip]", PROXY2.resolveActionTooltip( "yo" ) );
        assertEquals( "c1CTT", PROXY2.resolveActionTooltip( "c1common" ) );
        assertEquals( "c1ATT", PROXY2.resolveActionTooltip( "c1action" ) );
        assertEquals( "p1CTT", PROXY2.resolveActionTooltip( "p1common" ) );
        assertEquals( "p1ATT", PROXY2.resolveActionTooltip( "p1action" ) );
        assertEquals( "c22CTT", PROXY2.resolveActionTooltip( "c2common" ) );
        assertEquals( "c22ATT", PROXY2.resolveActionTooltip( "c2action" ) );
        assertEquals( "p22CTT", PROXY2.resolveActionTooltip( "p2common" ) );
        assertEquals( "p22ATT", PROXY2.resolveActionTooltip( "p2action" ) );
    }

    public void testInputTooltip()
            throws Exception {
        assertEquals( "[yoTooltip]", BASE.resolveInputTooltip( "yo" ) );
        assertEquals( "[c1commonTooltip]", BASE.resolveInputTooltip( "c1common" ) );
        assertEquals( "[c1inputTooltip]", BASE.resolveInputTooltip( "c1input" ) );
        assertEquals( "[p1commonTooltip]", BASE.resolveInputTooltip( "p1common" ) );
        assertEquals( "[p1inputTooltip]", BASE.resolveInputTooltip( "p1input" ) );
        assertEquals( "[c2commonTooltip]", BASE.resolveInputTooltip( "c2common" ) );
        assertEquals( "[c2inputTooltip]", BASE.resolveInputTooltip( "c2input" ) );
        assertEquals( "[p2commonTooltip]", BASE.resolveInputTooltip( "p2common" ) );
        assertEquals( "[p2inputTooltip]", BASE.resolveInputTooltip( "p2input" ) );

        assertEquals( "[yoTooltip]", PROXY1.resolveInputTooltip( "yo" ) );
        assertEquals( "c1CTT", PROXY1.resolveInputTooltip( "c1common" ) );
        assertEquals( "c1ITT", PROXY1.resolveInputTooltip( "c1input" ) );
        assertEquals( "p1CTT", PROXY1.resolveInputTooltip( "p1common" ) );
        assertEquals( "p1ITT", PROXY1.resolveInputTooltip( "p1input" ) );
        assertEquals( "c2CTT", PROXY1.resolveInputTooltip( "c2common" ) );
        assertEquals( "c2ITT", PROXY1.resolveInputTooltip( "c2input" ) );
        assertEquals( "p2CTT", PROXY1.resolveInputTooltip( "p2common" ) );
        assertEquals( "p2ITT", PROXY1.resolveInputTooltip( "p2input" ) );

        assertEquals( "[yoTooltip]", PROXY2.resolveInputTooltip( "yo" ) );
        assertEquals( "c1CTT", PROXY2.resolveInputTooltip( "c1common" ) );
        assertEquals( "c1ITT", PROXY2.resolveInputTooltip( "c1input" ) );
        assertEquals( "p1CTT", PROXY2.resolveInputTooltip( "p1common" ) );
        assertEquals( "p1ITT", PROXY2.resolveInputTooltip( "p1input" ) );
        assertEquals( "c22CTT", PROXY2.resolveInputTooltip( "c2common" ) );
        assertEquals( "c22ITT", PROXY2.resolveInputTooltip( "c2input" ) );
        assertEquals( "p22CTT", PROXY2.resolveInputTooltip( "p2common" ) );
        assertEquals( "p22ITT", PROXY2.resolveInputTooltip( "p2input" ) );
    }

    public void testError()
            throws Exception {
        assertEquals( "[yo]", BASE.resolveError( "yo" ) );
        assertEquals( "[c1common]", BASE.resolveError( "c1common" ) );
        assertEquals( "[c1error]", BASE.resolveError( "c1error" ) );
        assertEquals( "[p1common]", BASE.resolveError( "p1common" ) );
        assertEquals( "[p1error]", BASE.resolveError( "p1error" ) );
        assertEquals( "[c2common]", BASE.resolveError( "c2common" ) );
        assertEquals( "[c2error]", BASE.resolveError( "c2error" ) );
        assertEquals( "[p2common]", BASE.resolveError( "p2common" ) );
        assertEquals( "[p2error]", BASE.resolveError( "p2error" ) );

        assertEquals( "[yo]", PROXY1.resolveError( "yo" ) );
        assertEquals( "c1C", PROXY1.resolveError( "c1common" ) );
        assertEquals( "c1E", PROXY1.resolveError( "c1error" ) );
        assertEquals( "p1C", PROXY1.resolveError( "p1common" ) );
        assertEquals( "p1E", PROXY1.resolveError( "p1error" ) );
        assertEquals( "c2C", PROXY1.resolveError( "c2common" ) );
        assertEquals( "c2E", PROXY1.resolveError( "c2error" ) );
        assertEquals( "p2C", PROXY1.resolveError( "p2common" ) );
        assertEquals( "p2E", PROXY1.resolveError( "p2error" ) );

        assertEquals( "[yo]", PROXY2.resolveError( "yo" ) );
        assertEquals( "c1C", PROXY2.resolveError( "c1common" ) );
        assertEquals( "c1E", PROXY2.resolveError( "c1error" ) );
        assertEquals( "p1C", PROXY2.resolveError( "p1common" ) );
        assertEquals( "p1E", PROXY2.resolveError( "p1error" ) );
        assertEquals( "c22C", PROXY2.resolveError( "c2common" ) );
        assertEquals( "c22E", PROXY2.resolveError( "c2error" ) );
        assertEquals( "p22C", PROXY2.resolveError( "p2common" ) );
        assertEquals( "p22E", PROXY2.resolveError( "p2error" ) );

        assertEquals( "[c1action]", BASE.resolveError( "c1action" ) ); // Action
        assertEquals( "[c2action]", BASE.resolveError( "c2action" ) ); // Action
        assertEquals( "[p1action]", BASE.resolveError( "p1action" ) ); // Action
        assertEquals( "[p2action]", BASE.resolveError( "p2action" ) ); // Action
        assertEquals( "[c1input]", BASE.resolveError( "c1input" ) ); // Label
        assertEquals( "[c1label]", BASE.resolveError( "c1label" ) ); // Label
        assertEquals( "[c2input]", BASE.resolveError( "c2input" ) ); // Label
        assertEquals( "[c2label]", BASE.resolveError( "c2label" ) ); // Label
        assertEquals( "[p1input]", BASE.resolveError( "p1input" ) ); // Label
        assertEquals( "[p1label]", BASE.resolveError( "p1label" ) ); // Label
        assertEquals( "[p2input]", BASE.resolveError( "p2input" ) ); // Label
        assertEquals( "[p2label]", BASE.resolveError( "p2label" ) ); // Label

        assertEquals( "[c1action]", PROXY1.resolveError( "c1action" ) ); // Action
        assertEquals( "[c2action]", PROXY1.resolveError( "c2action" ) ); // Action
        assertEquals( "[p1action]", PROXY1.resolveError( "p1action" ) ); // Action
        assertEquals( "[p2action]", PROXY1.resolveError( "p2action" ) ); // Action
        assertEquals( "[c1input]", PROXY1.resolveError( "c1input" ) ); // Label
        assertEquals( "[c1label]", PROXY1.resolveError( "c1label" ) ); // Label
        assertEquals( "[c2input]", PROXY1.resolveError( "c2input" ) ); // Label
        assertEquals( "[c2label]", PROXY1.resolveError( "c2label" ) ); // Label
        assertEquals( "[p1input]", PROXY1.resolveError( "p1input" ) ); // Label
        assertEquals( "[p1label]", PROXY1.resolveError( "p1label" ) ); // Label
        assertEquals( "[p2input]", PROXY1.resolveError( "p2input" ) ); // Label
        assertEquals( "[p2label]", PROXY1.resolveError( "p2label" ) ); // Label

        assertEquals( "[c1action]", PROXY2.resolveError( "c1action" ) ); // Action
        assertEquals( "[c2action]", PROXY2.resolveError( "c2action" ) ); // Action
        assertEquals( "[p1action]", PROXY2.resolveError( "p1action" ) ); // Action
        assertEquals( "[p2action]", PROXY2.resolveError( "p2action" ) ); // Action
        assertEquals( "[c1input]", PROXY2.resolveError( "c1input" ) ); // Label
        assertEquals( "[c1label]", PROXY2.resolveError( "c1label" ) ); // Label
        assertEquals( "[c2input]", PROXY2.resolveError( "c2input" ) ); // Label
        assertEquals( "[c2label]", PROXY2.resolveError( "c2label" ) ); // Label
        assertEquals( "[p1input]", PROXY2.resolveError( "p1input" ) ); // Label
        assertEquals( "[p1label]", PROXY2.resolveError( "p1label" ) ); // Label
        assertEquals( "[p2input]", PROXY2.resolveError( "p2input" ) ); // Label
        assertEquals( "[p2label]", PROXY2.resolveError( "p2label" ) ); // Label
    }
}