manager_bad.cc

Go to the documentation of this file.

/*
 * manager_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 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 <iostream>
#include <assert_pp.h>

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

#include <StubTask.hh>

using namespace std;

/**
 * Executable arguments.
 */
static 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;                                       \
        }                                                       \
    }                                                           \
    catch(const CORBA::Exception &_e)                           \
    {                                                           \
        if( args.verbose )                                      \
        {                                                       \
            cerr << "Tried \""                                  \
                 << __STRING(BLOCK)                             \
                 << "\" at line "                               \
                 << __LINE__                                    \
                 << " and got unexpected 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

    try
    {
        /* 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);
        
        {
            Broker::CPUReserve cr;
            
            /* Check nil to Broker::Manager::ChangeTaskCPU */
            expect_catch(manager->ChangeTaskCPU(Broker::RealTimeTask::_nil(),
                                                cr),
                         CORBA::BAD_PARAM);
        }
        
        task = Broker::Task::_nil();
        delete st;
        
        manager = Broker::Manager::_nil();
        delete mi;
    }
    catch(const CORBA::Exception &e)
    {
        cerr << "Caught unexpected exception: " << e << endl;
    }
    
    return( retval );
}

---