rk_task_bad.cc

Go to the documentation of this file.

/*
 * rk_task_bad.cc
 *
 * Copyright (c) 2003, 2004 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rk_task_bad.cc
 *
 * Test the RKTask class to make sure it detects bad inputs.
 */

#include "config.h"

/* Make sure assert is on */
#if !defined(DEBUG)
#define DEBUG 1
#endif

#include <stdlib.h>
#include <assert.h>
#include <assert_pp.h>

#include <rk_stub.h>

#include <iostream>

#include <tao/Typecode.h>
#include <RKTask.hh>
#include <ManagerImpl.hh>

#include "StubPolicy.hh"

using namespace std;

struct {
    int verbose;
} args = {
    1,
};

/**
 * Macro used to catch and possibly print out expected exceptions.
 *
 * @param BLOCK The block of code to execute in a try/catch.
 * @param EXCEPTION The expected exception.
 */
#define expect_catch(BLOCK, EXCEPTION)                          \
{                                                               \
    try                                                         \
    {                                                           \
        BLOCK;                                                  \
        ensure(0);                                              \
    }                                                           \
    catch(const EXCEPTION &_e)                                  \
    {                                                           \
        if( args.verbose )                                      \
        {                                                       \
            cerr << "Tried \""                                  \
                 << __STRING(BLOCK)                             \
                 << "\" at line "                               \
                 << __LINE__                                    \
                 << " and got expected exception \""            \
                 << _e                                          \
                 << "\""                                        \
                 << endl;                                       \
            try                                                 \
            {                                                   \
                throw _e;                                       \
            }                                                   \
            catch(const Broker::InvalidTaskParameter &_itp)     \
            {                                                   \
                cerr << "message="                              \
                     << _itp.message                            \
                     << "; pair={ name="                        \
                     << _itp.pair.name                          \
                     << "; value_kind="                         \
                     << _itp.pair.value.type()->kind()          \
                     << " }"                                    \
                     << endl;                                   \
            }                                                   \
            catch(const Broker::DuplicateTaskParameter &_dtp)   \
            {                                                   \
                cerr << "name="                                 \
                     << _dtp.name                               \
                     << endl;                                   \
            }                                                   \
            catch(const Broker::DuplicateScheduleParameter &_dsp)       \
            {                                                   \
                cerr << "name="                                 \
                     << _dsp.name                               \
                     << endl;                                   \
            }                                                   \
            catch(const Broker::MissingTaskParameter &_mtp)     \
            {                                                   \
                cerr << "name="                                 \
                     << _mtp.name                               \
                     << endl;                                   \
            }                                                   \
            catch(const Broker::InvalidScheduleParameter &_itp) \
            {                                                   \
                cerr << "message="                              \
                     << _itp.message                            \
                     << "; pair={ name="                        \
                     << _itp.pair.name                          \
                     << "; value_kind="                         \
                     << _itp.pair.value.type()->kind()          \
                     << " }"                                    \
                     << endl;                                   \
            }                                                   \
            catch(const Broker::MissingScheduleParameter &_msp) \
            {                                                   \
                cerr << "name="                                 \
                     << _msp.name                               \
                     << endl;                                   \
            }                                                   \
            catch(const CORBA::SystemException &_se)            \
            {                                                   \
                cerr << "system-exception '"                    \
                     << _se                                     \
                     << "' at line "                            \
                     << __LINE__                                \
                     << endl;                                   \
            }                                                   \
        }                                                       \
    }                                                           \
    catch(...)                                                  \
    {                                                           \
        cerr << "unknown exception at line "                    \
             << __LINE__                                        \
             << endl;                                           \
        exit(1);                                                \
    }                                                           \
}

int main(int argc, char *argv[])
{
    int retval = EXIT_SUCCESS;
    
    rk_stub_set_mode(RK_STUB_LOG);

    try
    {
        /* ORB/POA setup */
        CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);
        CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
    
        PortableServer::POA_var root_poa =
            PortableServer::POA::_narrow(obj.in());
        PortableServer::POAManager_var mgr = root_poa->the_POAManager();
        mgr->activate();

        /* Broker setup */
        Broker::ScheduleParameters sp;
        Broker::RealTimeTask_var rtt;
        Broker::Manager_var manager;
        Broker::TaskParameters tp;
        Broker::Task_var task;
        pid_t client_pid;

        ManagerImpl *mi = new ManagerImpl("manager");
        StubPolicy *spi = new StubPolicy("dummy");

        manager = mi->_this();
        Broker::Policy_var policy = spi->_this();
    
        manager->CurrentPolicy(policy.in());

        /* ... Test the constructor */

        tp.length(0); /* ... no 'name' or 'pid' values */
    
        expect_catch(new RKTask(tp), Broker::MissingTaskParameter);

        tp.length(1);
        tp[0].name = "name";
        tp[0].value <<= (CORBA::UShort)1; /* ... bad type */
    
        expect_catch(new RKTask(tp), Broker::InvalidTaskParameter);

        tp.length(1);
        tp[0].name = "name";
        tp[0].value <<= "really_long_name_that_should_cause_an_exception";
    
        expect_catch(new RKTask(tp), Broker::InvalidTaskParameter);

        tp.length(2);
        tp[0].name = "name";
        tp[0].value <<= "test";
        tp[1].name = "name";
        tp[1].value <<= "test"; /* ... duplicate 'name' value */

        expect_catch(new RKTask(tp), Broker::DuplicateTaskParameter);

        tp.length(1);
    
        RKTask *rkt = new RKTask(tp);

        task = rkt->_this();
        rtt = Broker::RealTimeTask::_narrow(task.in());
        assert(!CORBA::is_nil(rtt.in()));

        /* ... Begin/EndCPUScheduling */
        expect_catch(task->EndCPUScheduling(), CORBA::BAD_INV_ORDER);

        sp.length(0); /* ... no 'period' value */

        task->SetManager(manager.in());
        
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::MissingScheduleParameter);

        sp.length(1);
        sp[0].name = "pid";
        sp[0].value <<= "hello"; /* ... bad type */
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::InvalidScheduleParameter);

        client_pid = -2;
        sp.length(1);
        sp[0].name = "pid";
        sp[0].value <<= client_pid; /* ... bad 'pid' value */
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::InvalidScheduleParameter);

        client_pid = rk_stub_mk_pid("test", NULL, NULL, NULL);

        sp.length(2);
        sp[0].name = "pid";
        sp[0].value <<= client_pid;
        sp[1].name = "pid";
        sp[1].value <<= client_pid; /* ... duplicate 'pid' value */
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::DuplicateScheduleParameter);

        sp.length(2);
        sp[0].name = "period";
        sp[0].value <<= "hello"; /* ... bad value */
        sp[1].name = "pid";
        sp[1].value <<= client_pid;
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::InvalidScheduleParameter);

        sp.length(2);
        sp[0].name = "deadline";
        sp[0].value <<= "hello"; /* ... bad value */
        sp[1].name = "pid";
        sp[1].value <<= client_pid;
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::InvalidScheduleParameter);

        sp.length(2);
        sp[0].name = "deadline";
        sp[0].value <<= "1000"; /* ... no 'period' */
        sp[1].name = "pid";
        sp[1].value <<= client_pid;
    
        expect_catch(task->BeginCPUScheduling(sp),
                     Broker::MissingScheduleParameter);

        sp.length(2);
        sp[0].name = "period";
        sp[0].value <<= "1000";

        task->BeginCPUScheduling(sp);

        /* Check begin without end. */
        expect_catch(task->BeginCPUScheduling(sp),
                     CORBA::BAD_INV_ORDER);

        /* Set compute time to a known good value, and... */
        rtt->SetComputeTime(250);
        /* change it to a bogus value, making sure that... */
        expect_catch(rtt->SetComputeTime(100000), CORBA::BAD_PARAM);
        /* the original good value is still returned. */
        assert(rtt->GetComputeTime() == 250);

        task->EndCPUScheduling();

        /* Check end without begin. */
        expect_catch(task->EndCPUScheduling(), CORBA::BAD_INV_ORDER);

    }
    catch(const CORBA::UserException &e)
    {
        cerr << e << endl;
        retval = EXIT_FAILURE;
    }
    catch(const CORBA::SystemException &e)
    {
        cerr << e << endl;
        retval = EXIT_FAILURE;
    }
    catch(...)
    {
        cerr << "Caught an unknown exception" << endl;
        retval = EXIT_FAILURE;
    }
    return( retval );
}

---