rk_bad.c

Go to the documentation of this file.

/*
 * rk_bad.c
 *
 * 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 rk_bad.c
 *
 * Test the rk functions to make sure they detect bad inputs.
 */

#include "config.h"

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

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

#include <rk.h>

#if defined(RK_STUB)
#include <rk_stub.h>
#endif

#include <timesFile.h>

/**
 * Make a bad input file.
 *
 * @param file_name The name of the file to create.
 * @param body The body of the newly created file.
 * @return True if the file was created, false otherwise.
 */
static int rbMakeBadFile(char *file_name, char *body)
{
    int retval = 0;
    FILE *file;
    
    require(file_name != NULL);
    require(body != NULL);

    if( (file = fopen(file_name, "w")) != NULL )
    {
        fprintf(file, "%s", body);
        fclose(file);

        retval = 1;
    }
    return( retval );
}

int main(int argc, char *argv[])
{
    struct cpu_reserve_attr cra, cra2;
    rk_resource_set_t rs;
    rk_reserve_t cr;
    int retval = 0;
    pid_t pid;

#if defined(RK_STUB)
    rk_stub_set_mode(RK_STUB_SIM);
#endif

    /* ... prime some variables for use later on */
#if defined(RK_STUB)
    pid = rk_stub_mk_pid("dummy", NULL, NULL, NULL);
#else
    pid = getpid();
#endif
    memset(&cra, 0, sizeof(cra));

    /* Make some good/bad input files. */
    assert(tfMakeTimesFile("test_cpu_times",
                           (const float[]){ 50.0, TIMES_FILE_TERMINATOR }));
    assert(rbMakeBadFile("bad1_cpu_times", "-1.0"));
    assert(rbMakeBadFile("bad2_cpu_times", "200.0"));
    assert(rbMakeBadFile("bad3_cpu_times", "foo"));
    
    /* BEGIN rk_resource_set_create */
    assert(rk_resource_set_create(NULL) == NULL);
    assert(errno == EINVAL);

    assert(rk_resource_set_create("") == NULL);
    assert(errno == EINVAL);

    {
        char bad_name[RSET_NAME_LEN + 1];

        memset(bad_name, 'a', sizeof(bad_name));
        bad_name[sizeof(bad_name) - 1] = '\0';
        assert(rk_resource_set_create(bad_name) == NULL);
        assert(errno == ENAMETOOLONG);

        bad_name[0] = 200;
        bad_name[1] = '\0';
        assert(rk_resource_set_create(bad_name) == NULL);
        assert(errno == EINVAL);
    }

    rs = rk_resource_set_create("test");

    /* BEGIN rk_resource_set_destroy */
    rk_resource_set_destroy(rs);
    rk_resource_set_destroy(rs);
    rk_resource_set_destroy(NULL);
    
    /* BEGIN rk_resource_set_attach_process */
    rs = rk_resource_set_create("test");
    
    assert(rk_resource_set_attach_process(NULL, -1) == -1 && errno == EINVAL);
    assert(rk_resource_set_attach_process(rs, -1) == -1 && errno == EINVAL);
    assert(rk_resource_set_attach_process(rs, 200000) == -1 && errno == ESRCH);
#if defined(RK_STUB)
    assert(rk_resource_set_attach_process(rs, MAX_PCB) == -1 &&
           errno == ESRCH);
#endif
    assert(rk_resource_set_attach_process(rs, pid + 1) == -1 &&
           errno == ESRCH);
    assert(rk_resource_set_attach_process(rs, pid) == 0);
    
    /* BEGIN rk_resource_set_detach_process */
    assert(rk_resource_set_detach_process(NULL, -1) == -1 && errno == EINVAL);
    assert(rk_resource_set_detach_process(rs, -1) == -1 && errno == EINVAL);
    assert(rk_resource_set_detach_process(rs, 200000) == -1 &&
           errno == EINVAL);
    assert(rk_resource_set_detach_process(rs, pid + 1) == -1 &&
           errno == ESRCH);
    assert(rk_resource_set_detach_process(rs, pid) == 0);

    /* BEGIN rk_resource_set_set_name */
    assert(rk_resource_set_set_name(NULL, NULL) == -1 && errno == EINVAL);
    assert(rk_resource_set_set_name(rs, NULL) == -1 && errno == EINVAL);
    assert(rk_resource_set_set_name(rs, "") == -1 && errno == EINVAL);
    assert(rk_resource_set_set_name(rs, "test2") == 0);

    /* BEGIN rk_resource_set_get_name */
    {
        char name[RSET_NAME_LEN];
        
        assert(rk_resource_set_get_name(NULL, NULL) == -1 && errno == EINVAL);
        assert(rk_resource_set_get_name(rs, NULL) == -1 && errno == EINVAL);
        assert(rk_resource_set_get_name(rs, name) == 0);
        assert(strcmp(name, "test2") == 0);
        /* Need to reset it to 'test' since thats what the files are called. */
        assert(rk_resource_set_set_name(rs, "test") == 0);
    }
    
    /* BEGIN rk_cpu_reserve_create */
    rk_resource_set_destroy(rs);
    cra.compute_time.tv_sec = 1;
    cra.period.tv_sec = 2;
    cra.deadline.tv_sec = 2;
    cra.reserve_type.sch_mode =
        cra.reserve_type.enf_mode =
        cra.reserve_type.rep_mode = RSV_SOFT;

    /* ... test bad input files */
    assert((rs = rk_resource_set_create("nonexistent")) != NULL);
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == ENOENT);
    rk_resource_set_destroy(rs);
    
    assert((rs = rk_resource_set_create("bad1")) != NULL);
#if defined(EFTYPE)
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EFTYPE);
#else
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
#endif
    rk_resource_set_destroy(rs);
    
    assert((rs = rk_resource_set_create("bad2")) != NULL);
#if defined(EFTYPE)
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EFTYPE);
#else
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
#endif
    rk_resource_set_destroy(rs);
    
    assert((rs = rk_resource_set_create("bad3")) != NULL);
#if defined(EFTYPE)
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EFTYPE);
#else
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
#endif
    rk_resource_set_destroy(rs);

    memset(&cra, 0, sizeof(cra));
    
    assert((rs = rk_resource_set_create("test")) != NULL);

    /* ... test regular inputs */
    assert(rk_cpu_reserve_create(NULL, NULL, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_create(rs, NULL, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_create(rs, &cr, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
    cra.compute_time.tv_sec = 1;
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
    cra.deadline.tv_sec = 2;
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
    cra.period.tv_sec = 2;
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
    cra.reserve_type.sch_mode =
        cra.reserve_type.enf_mode =
        cra.reserve_type.rep_mode = 5000;
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == -1 && errno == EINVAL);
    cra.reserve_type.sch_mode =
        cra.reserve_type.enf_mode =
        cra.reserve_type.rep_mode = RSV_SOFT;
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == 0);

    /* BEGIN rk_cpu_reserve_delete */
    rk_cpu_reserve_delete(NULL);
    rk_cpu_reserve_delete(rs);
    rk_cpu_reserve_delete(rs);
    
    /* BEGIN rk_cpu_reserve_get_attr */
    assert(rk_cpu_reserve_create(rs, &cr, &cra) == 0);
    
    assert(rk_cpu_reserve_get_attr(NULL, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_get_attr(cr, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_get_attr(cr, &cra2) == 0);
    assert(memcmp(&cra, &cra2, sizeof(cra)) == 0);

    /* BEGIN rk_cpu_reserve_ctl */
    memset(&cra, 0, sizeof(cra));
    assert(rk_cpu_reserve_ctl(rs, NULL) == -1 && errno == EINVAL);
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOSPC);
    cra.compute_time.tv_sec = 1;
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOSPC);
    cra.deadline.tv_sec = 2;
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOSPC);
    cra.period.tv_sec = 2;
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOSPC);
    cra.reserve_type.sch_mode =
        cra.reserve_type.enf_mode =
        cra.reserve_type.rep_mode = 5000;
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOSPC);
    cra.reserve_type.sch_mode =
        cra.reserve_type.enf_mode =
        cra.reserve_type.rep_mode = RSV_SOFT;
    assert(rk_cpu_reserve_ctl(rs, &cra) == 0);
    
    rk_cpu_reserve_delete(rs);
    
    assert(rk_cpu_reserve_ctl(rs, &cra) == -1 && errno == ENOTCONN);

    rk_resource_set_destroy(rs);

    return( retval );
}

---