t_tc_path.c

Go to the documentation of this file.

/*
** Copyright (C) 2004, 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: t_tc_path.c,v 1.5 2005/06/08 04:38:39 klmitch Exp $
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "test-harness.h"

#include "treeconf_int.h"

RCSTAG("@(#)$Id: t_tc_path.c,v 1.5 2005/06/08 04:38:39 klmitch Exp $");

TEST_PROG(t_tc_path, "Test tc_path() function")
TEST_DEP(t_tc_path, t_tc_break)

struct test {
  const char *test;           
  const char *path;           
  const char *def;            
  unsigned int flags;         
  unsigned int xret;          
  int elem_cnt;               
  int elem_loc;               
  struct test_elem *elems;    
  int subst_cnt;        
  treeconf_subst_t *substs;   
};

struct test_elem {
  const char *filename;       
  unsigned int test_flags;    
  unsigned int ret_val;       
};

#define TEST_ACCESS     0x0001      /* should access return true for this one? */

#define TEST_XSEARCHED  0x1000      /* access call expected */

#define TEST_XCALLED    0x2000      /* callback expected */

#define TEST_SEARCHED   0x4000      /* did access get called? */

#define TEST_CALLED     0x8000      /* was callback called? */

#define TEST_EXPECTED   (TEST_XSEARCHED | TEST_XCALLED)

#define TEST_ACTUAL     (TEST_SEARCHED | TEST_CALLED)

#define TEST_ELEM(name, flags, ret) { (name), (flags), (ret) }

#define TEST_PATH(test, path, default, flags, xret, cnt, elems, s_cnt, subs)  \
      { TEST_NAME(test), (path), (default), (flags), (xret), (cnt), 0,      \
        (elems), (s_cnt), (subs) }

#define TEST_ELEMS(elems)     (sizeof(elems) / sizeof(struct test_elem))

static struct test *curr_test = 0;

int
access(const char *pathname, int mode)
{
  if (!curr_test) /* allow initial tc_path() call test */
    return 0;

  /* sanity-check the test... */
  if (curr_test->elem_loc >= curr_test->elem_cnt ||
      strcmp(pathname, curr_test->elems[curr_test->elem_loc].filename))
    FAIL(curr_test->test, FATAL(0), "access() passed unexpected pathname "
       "\"%s\"", pathname);

  /* mark searched */
  curr_test->elems[curr_test->elem_loc].test_flags |= TEST_SEARCHED;

  /* return what we're supposed to return */
  return curr_test->elems[curr_test->elem_loc++].test_flags & TEST_ACCESS ?
    0 : -1;
}

static unsigned int
callback(const char *file, void *data)
{
  if (!curr_test) /* allow initial tc_path() call test */
    return 0;

  /* sanity-check the test... */
  if (!curr_test->elem_loc ||
      curr_test->elem_loc > curr_test->elem_cnt ||
      strcmp(file, curr_test->elems[curr_test->elem_loc - 1].filename) ||
      !(curr_test->elems[curr_test->elem_loc - 1].test_flags & TEST_SEARCHED))
    FAIL(curr_test->test, FATAL(0), "callback() passed unexpected pathname "
       "\"%s\"", file);

  /* mark called */
  curr_test->elems[curr_test->elem_loc - 1].test_flags |= TEST_CALLED;

  /* return what we're supposed to return */
  return curr_test->elems[curr_test->elem_loc - 1].ret_val;
}

static void
do_test(struct test *test)
{
  unsigned int err;
  int i;

  curr_test = test; /* this is the current test... */

  /* call tc_path... */
  err = tc_path(test->path, test->def, test->substs, test->subst_cnt,
            test->flags, callback, 0);

  /* correct return value? */
  if (err != test->xret) {
    FAIL(test->test, 0, "tc_path() call failed with unexpected return %u",
       err);
    return;
  }

  /* OK, check all the elements and make sure they're correct */
  for (err = 0, i = 0; i < test->elem_cnt; i++)
    if ((((test->elems[i].test_flags & TEST_ACTUAL) >> 2) &
       (test->elems[i].test_flags & TEST_EXPECTED)) !=
      (test->elems[i].test_flags & TEST_EXPECTED))
      fprintf(stderr, "%s:%d:%d: searched/called mismatch for element "
            "\"%s\": 0x%04x\n", test->test, i, err++,
            test->elems[i].filename, test->elems[i].test_flags);

  /* pass or fail the test */
  if (err)
    FAIL(test->test, 0, "tc_path() call did not properly process search");
  else
    PASS(test->test, "tc_path() call properly processed search");
}

TEST_DECL(t_tc_path, tc_path_basic, "Test that tc_path() works correctly "
        "for basic tests")
static struct test_elem basic_elems[] = {
  TEST_ELEM("foo", TEST_XSEARCHED, 0),
  TEST_ELEM("baz", TEST_XSEARCHED, 0),
  TEST_ELEM("bink", TEST_ACCESS | TEST_XCALLED | TEST_XSEARCHED, 0),
  TEST_ELEM("bar", TEST_ACCESS, 0)
};

TEST_DECL(t_tc_path, tc_path_all, "Test that tc_path() with TC_PATH_ALL "
        "searches all files")
static struct test_elem all_elems[] = {
  TEST_ELEM("foo", TEST_ACCESS | TEST_XCALLED | TEST_XSEARCHED, 0),
  TEST_ELEM("baz", TEST_ACCESS | TEST_XCALLED | TEST_XSEARCHED, 0),
  TEST_ELEM("bink", TEST_XSEARCHED, 0),
  TEST_ELEM("bar", TEST_XSEARCHED, 0)
};

treeconf_subst_t substs[] = {
  TC_SUBST_INIT('a', "foo", 0),
  TC_SUBST_INIT('b', "baz", TC_SUBST_INSECURE),
  TC_SUBST_INIT('c', "bink", 0),
  TC_SUBST_INIT('d', "bar", TC_SUBST_INSECURE)
};

#define NUM_SUBSTS      (sizeof(substs) / sizeof(treeconf_subst_t))

TEST_DECL(t_tc_path, tc_path_substs, "Test that tc_path() handles "
        "substitutions properly")


static struct test_elem subst_elems[] = {
  TEST_ELEM("foo", TEST_XSEARCHED, 0),
  TEST_ELEM("baz", TEST_XSEARCHED, 0),
  TEST_ELEM("bink", TEST_XSEARCHED, 0),
  TEST_ELEM("bar", TEST_XSEARCHED, 0)
};

TEST_DECL(t_tc_path, tc_path_secure, "Test that tc_path() handles "
        "security properly")
static struct test_elem secure_elems[] = {
  TEST_ELEM("foo", TEST_XSEARCHED, 0),
  TEST_ELEM("bink", TEST_XSEARCHED, 0)
};

static struct test tests[] = {
  TEST_PATH(tc_path_basic, "foo::bar", "baz:bink", 0, 0,
          TEST_ELEMS(basic_elems), basic_elems, 0, 0),
  TEST_PATH(tc_path_all, "foo::bar", "baz:bink", TC_PATH_ALL, 0,
          TEST_ELEMS(all_elems), all_elems, 0, 0),
  TEST_PATH(tc_path_substs, "%a::%d", "%b:%c", TC_PATH_ALL, 0,
          TEST_ELEMS(subst_elems), subst_elems, NUM_SUBSTS, substs),
  TEST_PATH(tc_path_secure, "%a::%d", "%b:%c", TC_PATH_SECURE | TC_PATH_ALL, 0,
          TEST_ELEMS(secure_elems), secure_elems, NUM_SUBSTS, substs)
};

#define NUM_TESTS (sizeof(tests) / sizeof(struct test))

int
main(int argc, char **argv)
{
  unsigned int err = 0;
  int i;

  TEST(t_tc_path, tc_path_call, "Test that tc_path() may be called",
       (!(err = tc_path(0, "foo:bar", 0, 0, 0, callback, 0))), FATAL(0),
       ("tc_path() call successful"),
       ("tc_path() call failed with error %u", err));

  for (i = 0; i < NUM_TESTS; i++)
    do_test(&tests[i]);

  return 0;
}

---