manager_bad.cc

Go to the documentation of this file.

/*
 * manager_bad.cc
 *
 * Copyright (c) 2003 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 manager_bad.cc
 *
 * Test the ManagerImpl class to make sure it detects bad inputs.
 */

#include "config.h"

#if !defined(DEBUG)
#define DEBUG 1
#endif

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

#include <BrokerC.h>
#include <ManagerImpl.hh>

#include <StubTask.hh>

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;                                       \
        }                                                       \
    }                                                           \
}

#if defined(BLOCK_ON_SEGV)
static void sigloop(int sig)
{
    for( ;; )
    {
        sleep(5);
    }
}
#endif

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

#if defined(BLOCK_ON_SEGV)
    signal(SIGSEGV, sigloop);
#endif
    
    /* ORB 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 */
    ManagerImpl *mi = new ManagerImpl("dummy");
    Broker::Manager_var manager;

    manager = mi->_this();

    StubTask *st = new StubTask();
    Broker::Task_var task;

    task = st->_this();
    
    assert(CORBA::is_nil(manager->CurrentPolicy()));

    manager->CurrentPolicy(Broker::Policy::_nil());

    Broker::ScheduleParameters sparam;
    sparam.length(0);

    /* Check nil argument to Broker::Manager::AddTask */
    expect_catch(manager->AddTask(Broker::Task::_nil(), sparam),
                 CORBA::BAD_PARAM);

    manager->AddTask(task.in(), sparam);
    /* Check re-add of same task. */
    expect_catch(manager->AddTask(task.in(), sparam), CORBA::BAD_PARAM);

    /* Check nil argument to Broker::Manager::RemoveTask */
    expect_catch(manager->RemoveTask(Broker::Task::_nil()), CORBA::BAD_PARAM);

    manager->RemoveTask(task.in());
    /* Check double remove. */
    expect_catch(manager->RemoveTask(task.in()), CORBA::BAD_PARAM);

    /* Check nil to Broker::Manager::ChangeTaskCPU */
    expect_catch(manager->ChangeTaskCPU(Broker::RealTimeTask::_nil(),
                                        0,
                                        0,
                                        0),
                 CORBA::BAD_PARAM);

    task = Broker::Task::_nil();
    delete st;

    manager = Broker::Manager::_nil();
    delete mi;
    
    return( retval );
}

---