TimingTest.java

package org.jacorb.test.bugs.bugjac493;

import static org.junit.Assert.assertNotSame;
import junit.framework.AssertionFailedError;
import org.jacorb.test.AMI_TimingServerHandler;
import org.jacorb.test.AMI_TimingServerHandlerOperations;
import org.jacorb.test.AMI_TimingServerHandlerPOATie;
import org.jacorb.test.TimingServer;
import org.jacorb.test.TimingServerHelper;
import org.jacorb.test._TimingServerStub;
import org.jacorb.test.harness.CallbackTestCase;
import org.jacorb.test.harness.ClientServerSetup;
import org.jacorb.util.Time;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.omg.CORBA.Policy;
import org.omg.CORBA.PolicyError;
import org.omg.CORBA.SetOverrideType;
import org.omg.CORBA.portable.ObjectImpl;
import org.omg.Messaging.ExceptionHolder;
import org.omg.Messaging.REPLY_END_TIME_POLICY_TYPE;
import org.omg.TimeBase.UtcT;
import org.omg.TimeBase.UtcTHelper;

/**
 * @author Andre Spiegel spiegel@gnu.org
 */
public class TimingTest extends CallbackTestCase
{
    private TimingServer server = null;

    @Before
    public void setUp() throws Exception
    {
        server = TimingServerHelper.narrow (setup.getServerObject());
    }


    // convenience methods for policy manipulation

    // These methods create policies in the really cumbersome way
    // via the ORB, so that the mechanism gets tested.  Each of the
    // policy types in org.jacorb.orb.policies also has a convenience
    // constructor that makes it much easier.
    private TimingServer clearPolicies (TimingServer server)
    {
        org.omg.CORBA.Object r = server._set_policy_override (new Policy[]{}, SetOverrideType.SET_OVERRIDE);
        return TimingServerHelper.narrow (r);
    }


    private TimingServer setReplyEndTime (TimingServer server, long unixTime)
    {
        UtcT corbaTime = Time.corbaTime (unixTime);

        org.omg.CORBA.ORB orb = setup.getClientOrb();
        org.omg.CORBA.Any any = orb.create_any();
        UtcTHelper.insert (any, corbaTime);
        try
        {
            Policy policy = orb.create_policy (REPLY_END_TIME_POLICY_TYPE.value, any);

            org.omg.CORBA.Object r = server._set_policy_override
                (new Policy[]{ policy }, SetOverrideType.ADD_OVERRIDE);

            return TimingServerHelper.narrow (r);
        }
        catch (PolicyError e)
        {
            throw new RuntimeException ("policy error: " + e);
        }
    }


    private AMI_TimingServerHandler ref ( ReplyHandler handler )
    {
        AMI_TimingServerHandlerPOATie tie =
            new AMI_TimingServerHandlerPOATie( handler )
            {
                public org.omg.CORBA.portable.OutputStream
                    _invoke( String method,
                             org.omg.CORBA.portable.InputStream _input,
                             org.omg.CORBA.portable.ResponseHandler handler )
                    throws org.omg.CORBA.SystemException
                {
                    try
                    {
                        return super._invoke( method, _input, handler );
                    }
                    catch( AssertionFailedError e )
                    {
                        return null;
                    }
                }
            };
        return tie._this( setup.getClientOrb() );
    }



    @BeforeClass
    public static void beforeClassSetUp() throws Exception
    {

        setup = new ClientServerSetup(TimingServerImpl.class.getName());
    }


    @Test
    public void testDuplicateObject1 ()
    {
       String ior1 = setup.getClientOrb().object_to_string (server);
       TimingServer server2 = TimingServerHelper.narrow (setup.getClientOrb ().string_to_object (ior1));

       assertNotSame (server, server2);
       assertNotSame(((ObjectImpl)server)._get_delegate (), ((ObjectImpl)server2)._get_delegate ());
    }


    @Test
    public void testDuplicateObject2 ()
    {
        TimingServer server2 = TimingServerHelper.narrow (server._duplicate());

        assertNotSame (server, server2);
        assertNotSame(((ObjectImpl)server)._get_delegate (), ((ObjectImpl)server2)._get_delegate ());
    }


    /**
     * Sets a ReplyEndTime which will
     * expire during the invocation.
     */
    @Test
    public void test_reply_end_time_async_expired()
    {
        ReplyHandler handler1 = new ReplyHandler()
        {
            public void operation_excep (ExceptionHolder excep_holder)
            {
                this.assertEquals (org.omg.CORBA.TIMEOUT.class,
                                   getException (excep_holder).getClass());
                pass();
            }
        };
        ReplyHandler handler2 = new ReplyHandler()
        {
            public void operation (int ami_return_val)
            {
                this.assertEquals (765, ami_return_val);
                pass();
            }
        };

        TimingServer server2 = clearPolicies (server);
        server2 = setReplyEndTime (server2, System.currentTimeMillis() + 1000);

        // This one should timeout (using the new server2)
        ((_TimingServerStub)server2).sendc_operation (ref (handler1), 767, 2000);
        handler1.wait_for_reply (4000);

        // This one should not timeout (using the original server)
        ((_TimingServerStub)server).sendc_operation (ref (handler2), 765, 2000);
        handler2.wait_for_reply (4000);
    }


    private class ReplyHandler extends CallbackTestCase.ReplyHandler
       implements AMI_TimingServerHandlerOperations
    {
       public void ex_op_excep(ExceptionHolder excep_holder)
       {
          wrong_exception ("ex_op_excep", excep_holder);
       }

       public void ex_op(char ami_return_val)
       {
          wrong_reply ("ex_op");
       }

       public void operation_excep(ExceptionHolder excep_holder)
       {
          wrong_exception ("operation_excep", excep_holder);
       }

       public void operation(int ami_return_val)
       {
          wrong_reply ("operation");
       }

       public void server_time_excep(ExceptionHolder excep_holder)
       {
          wrong_exception ("server_time_excep", excep_holder);
       }

       public void server_time(long ami_return_val)
       {
          wrong_reply ("server_time");
       }
    }
}