t_treeconf.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_treeconf.c,v 1.7 2005/06/08 04:38:39 klmitch Exp $
*/
#include "test-harness.h"

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

#include "treeconf_int.h"

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

TEST_PROG(t_treeconf, "Test treeconf function suite")
TEST_DEP(t_treeconf, t_tc_break)

static int change;

static void
t_change(treeconf_ctx_t *ctx, treeconf_node_t *node)
{
  change++;
  return;
}

static int
nodown_false(treeconf_ctx_t *ctx, treeconf_node_t *parent,
           treeconf_str_t *name, int elements)
{
  return 0;
}

static int
nodown_true(treeconf_ctx_t *ctx, treeconf_node_t *parent,
          treeconf_str_t *name, int elements)
{
  return 1;
}

int
main(int argc, char **argv)
{
  treeconf_ctx_t ctx = TREECONF_CTX_INIT;
  treeconf_node_t *node = 0, *node2 = 0;
  const char *value;
  unsigned int err = 0;

  /***************************************************************************/
  /* Test simple tc_register cases                                           */
  /***************************************************************************/

  /* Create tree node "foo"--checks creation of tree nodes */
  TEST(t_treeconf, tc_register_treenode,
       "Test creation of tree nodes by tc_register()",
       (!(err = tc_register(&ctx, "foo", 0, 0, 0, 0, 0)) &&
      (tn_type(tx_config(&ctx)) & TC_NODETYPE_MASK) == TC_NODETYPE_NODE),
       FATAL(0),
       ("tc_register() successfully created tree node \"foo\""),
       ("tc_register() call failed with error %u", err));

  /* Create variable node "foo.bar" with default "bar"--checks creation
   * of variable nodes
   */
  TEST(t_treeconf, tc_register_varnode,
       "Test creation of variable nodes by tc_register()",
       (!(err = tc_register(&ctx, "foo.bar", "bar", 0, 0, 0, 0))), FATAL(0),
       ("tc_register() successfully created variable node \"foo.bar\""),
       ("tc_register() call failed with error %u", err));

  /* Create tree node "foo.baz.bink"--checks creation of a tree node with
   * implicit nodes
   */
  TEST(t_treeconf, tc_register_impltree,
       "Test creation of implicit tree nodes for tree nodes by tc_register()",
       (!(err = tc_register(&ctx, "foo.baz.bink", 0, 0, 0, 0, 0))), FATAL(0),
       ("tc_register() successfully created tree node \"foo.baz.bink\""),
       ("tc_register() call failed with error %u", err));

  /* Create variable node "foo.bink.foo" with default "baz" and a change
   * callback--checks creation of a variable node with implicit nodes
   */
  TEST(t_treeconf, tc_register_implvar,
       "Test creation of implicit tree nodes for var nodes by tc_register()",
       (!(err = tc_register(&ctx, "foo.bink.foo", "baz", 0, 0, t_change, 0))),
       FATAL(0),
       ("tc_register() successfully created variable node \"foo.bink.foo\""),
       ("tc_register() call failed with error %u", err));

  /* Attempt creation of "foo.baz" variable node with default "blah"--checks
   * rejection of variable nodes replacing implicit tree nodes
   */
  TEST(t_treeconf, tc_register_replimpl,
       "Test tc_register() rejects replacement of implicit tree nodes",
       ((err = tc_register(&ctx, "foo.baz", "blah", 0, 0, 0, 0)) ==
      TC_ERR_MULTREG), 0,
       ("tc_register() rejected replacement of implicit tree node with a "
      "variable node"),
       ("tc_register() did not reject variable node replacement and returned "
      "error code %u", err));

  /***************************************************************************/
  /* Test simple tc_find cases                                               */
  /***************************************************************************/

  /* Attempt lookup of node "foo" */
  TEST(t_treeconf, tc_find_node,
       "Test tc_find() can find desired existing node",
       (!(err = tc_find(&ctx, "foo", &node, 0)) && node), FATAL(0),
       ("tc_find() successfully located variable node \"foo\""),
       ("tc_find() failed to locate existing variable node \"foo\" and "
      "returned error code %u", err));

  /* Attempt lookup of non-existant node "root"; should return ENOENT. */
  TEST(t_treeconf, tc_find_none_root,
       "Test that tc_find() fails to find non-existant root nodes",
       ((err = tc_find(&ctx, "root", &node2, 0)) == ENOENT), FATAL(0),
       ("tc_find() correctly returned failure when looking up \"root\""),
       ("tc_find() returned unexpected error code %u looking up non-existant "
      "node \"root\"", err));

  /* Attempt lookup of non-existant node "foo.none.here"; should return
   * ENOENT.
   */
  TEST(t_treeconf, tc_find_none_leaf,
       "Test that tc_find() fails to find non-existant leaf nodes",
       ((err = tc_find(&ctx, "foo.none.here", &node2, 0)) == ENOENT), FATAL(0),
       ("tc_find() correctly returned failure when looking up "
      "\"foo.none.here\""),
       ("tc_find() returned unexpected error code %u looking up non-existant "
      "node \"foo.none.here\"", err));

  /* Test that nodown returning false results in ENOENT */
  tn_nodown(node) = nodown_false;
  TEST(t_treeconf, tc_find_nodown_false,
       "Test that tc_find() will not create implicit nodes when nodown "
       "returns false",
       ((err = tc_find(&ctx, "foo.nodown.here", &node2, 0)) == ENOENT),
       FATAL(0),
       ("tc_find() correctly returned failure looking up \"foo.nodown.here\" "
      "when nodown callback returned false"),
       ("tc_find() returned unexpected error code %u looking up non-existant "
      "node \"foo.nodown.here\" with nodown returning false", err));

  /* Test that nodown returning true results in implicit node creation */
  tn_nodown(node) = nodown_true;
  TEST(t_treeconf, tc_find_nodown_true,
       "Test that tc_find() will create implicit nodes when nodown returns "
       "true",
       (!(err = tc_find(&ctx, "foo.nodown.here", &node2, 0)) &&
      (tn_type(node2) & TC_NODETYPE_IMPLICIT)), FATAL(0),
       ("tc_find() successfully created implicit node \"foo.nodown.here\" "
      "when nodown callback returned true"),
       ("tc_find() returned unexpected error code %u looking up non-existant "
      "node \"foo.nodown.here\" with nodown returning true", err));

  /***************************************************************************/
  /* Test complex tc_register cases                                          */
  /***************************************************************************/

  /* Test that relative registration works */
  TEST(t_treeconf, tc_register_relative,
       "Test creation of nodes relative to a given node",
       (!(err = tc_register(&ctx, "qux", "aye", node, 0, 0, 0))), FATAL(0),
       ("tc_register() successfully created node \"qux\" relative to parent "
      "node \"foo\""),
       ("tc_register() failed to create node \"qux\" relative to parent node "
      "\"foo\" and returned error code %u", err));

  /* Test that implicit nodes can be overridden */
  TEST(t_treeconf, tc_register_override,
       "Test that an implicit node can be overridden by an explicit node",
       (!(err = tc_register(&ctx, "foo.nodown", "blah", 0, 0, 0, 0)) &&
      !(err = tc_find(&ctx, "foo.nodown", &node2, 0)) &&
      !(tn_type(node2) & TC_NODETYPE_IMPLICIT) &&
      (err = tc_find(&ctx, "foo.nodown.here", &node2, 0)) == ENOENT),
       FATAL(0),
       ("tc_register() override of implicit node successful"),
       ("tc_register() failed, tc_find() failed, node created as implicit, "
      "or subnode still exists; error code %u", err));

  /***************************************************************************/
  /* Test tc_get                                                             */
  /***************************************************************************/

  /* Test that tc_get() won't return non-existant variables */
  TEST(t_treeconf, tc_get_noent,
       "Test that tc_get() doesn't retrieve non-existant nodes",
       ((err = tc_get(&ctx, "bar", 0, 0)) == ENOENT), 0,
       ("tc_get() properly failed to retrieve non-existant variable"),
       ("tc_get() failed in retrieving non-existant variable with unexpected "
      "error code %u", err));

  /* Test that tc_get() won't try to return a value from a tree node */
  TEST(t_treeconf, tc_get_mismatch,
       "Test that tc_get() will not retrieve a tree node's value",
       ((err = tc_get(&ctx, "foo", 0, 0)) == TC_ERR_MISMATCH), 0,
       ("tc_get() properly failed to retrieve tree node as variable"),
       ("tc_get() failed in retrieving tree node as variable with unexpected "
      "error code %u", err));

  /* Test that tc_get() returns the correct value */
  TEST(t_treeconf, tc_get_variable,
       "Test that tc_get() will properly retrieve a variable's value",
       (!(err = tc_get(&ctx, "foo.bar", &value, 0)) &&
      !strcmp(value, "bar")), 0,
       ("tc_get() properly retrieved value of \"foo.bar\""),
       ("tc_get() failed to retrieve correct value of \"foo.bar\"; error code "
      "%u", err));

  /***************************************************************************/
  /* Test tc_set                                                             */
  /***************************************************************************/

  /* Test tc_set() on a basic variable */
  TEST(t_treeconf, tc_set_basic,
       "Test that tc_set() will set a simple variable",
       (!(err = tc_set(&ctx, "foo.bar", "rab", 0)) &&
      !(err = tc_get(&ctx, "foo.bar", &value, 0)) &&
      !strcmp(value, "rab")), FATAL(0),
       ("tc_set() set \"foo.bar\" to \"rab\""),
       ("tc_set() failed to set \"foo.bar\" to \"rab\"; error code %u", err));

  /* Test tc_set() rejects non-existant node "root"; should return ENOENT. */
  TEST(t_treeconf, tc_set_none_root,
       "Test that tc_set() fails to set non-existant root nodes",
       ((err = tc_set(&ctx, "root", "blah", 0)) == ENOENT), FATAL(0),
       ("tc_set() correctly returned failure when setting \"root\""),
       ("tc_set() returned unexpected error code %u setting non-existant node "
      "\"root\"", err));

  /* Test tc_set() rejects non-existant leaf node "foo.none.here" when nodown
   * not set; should return ENOENT.
   */
  tn_nodown(node) = 0;
  TEST(t_treeconf, tc_set_none_nodown_unset,
       "Test that tc_set() fails to set non-existant leaf nodes with no "
       "nodown set",
       ((err = tc_set(&ctx, "foo.none.here", "blah", 0)) == ENOENT), FATAL(0),
       ("tc_set() correctly returned failure when setting \"foo.none.here\""),
       ("tc_set() returned unexpected error code %u setting non-existant node "
      "\"foo.none.here\"", err));

  /* Test tc_set() rejects non-existant leaf node "foo.none.here" when nodown
   * returns false; should return ENOENT.
   */
  tn_nodown(node) = nodown_false;
  TEST(t_treeconf, tc_set_none_nodown_false,
       "Test that tc_set() fails to set non-existant leaf nodes with nodown "
       "returning false",
       ((err = tc_set(&ctx, "foo.none.here", "blah", 0)) == ENOENT), FATAL(0),
       ("tc_set() correctly returned failure when setting \"foo.none.here\""),
       ("tc_set() returned unexpected error code %u setting non-existant node "
      "\"foo.none.here\"", err));

  /* Test that tc_set() may create implicit nodes */
  tn_nodown(node) = nodown_true;
  TEST(t_treeconf, tc_set_implicit,
       "Test that tc_set() may create implicit nodes if nodown returns true",
       (!(err = tc_set(&ctx, "foo.implicit.variable", "varb", 0)) &&
      !(err = tc_find(&ctx, "foo.implicit", &node, 0)) &&
      tn_type(node) == (TC_NODETYPE_IMPLICIT | TC_NODETYPE_NODE) &&
      !(err = tc_find(&ctx, "foo.implicit.variable", &node, 0)) &&
      tn_type(node) == (TC_NODETYPE_IMPLICIT | TC_NODETYPE_VARIABLE) &&
      !strcmp(tn_value(node), "varb")), FATAL(0),
       ("tc_set() implicitly created \"foo.implicit\" and "
      "\"foo.implicit.variable\""),
       ("tc_set() failed to create \"foo.implicit.variable\" with implicit "
      "nodes; error code %u", err));

  /* Now mask foo.implicit.variable by setting foo.implicit */
  TEST(t_treeconf, tc_set_imploverride,
       "Test that tc_set() may override implicitly created tree nodes",
       (!(err = tc_set(&ctx, "foo.implicit", "impl", 0)) &&
      !(err = tc_find(&ctx, "foo.implicit", &node, 0)) &&
      tn_type(node) == (TC_NODETYPE_IMPLICIT | TC_NODETYPE_VARIABLE) &&
      !strcmp(tn_value(node), "impl") &&
      (err = tc_find(&ctx, "foo.implicit.variable", &node, 0)) == ENOENT),
       0,
       ("tc_set() overrode implicitly created \"foo.implicit\" tree node "
      "with a variable node"),
       ("tc_set() failed to override implicitly created \"foo.implicit\" "
      "tree node; error code %u", err));

  /* tc_set() may not override non-implicit tree nodes */
  TEST(t_treeconf, tc_set_nonimplicit,
       "Test that tc_set() may not override explicitly created tree nodes",
       ((err = tc_set(&ctx, "foo", "oof", 0)) == TC_ERR_MISMATCH), FATAL(0),
       ("tc_set() correctly refused to override explicit tree node"),
       ("tc_set() returned unexpected error code %u", err));

  /* tc_set() must call the change callback */
  change = 0; /* zero the change count */
  TEST(t_treeconf, tc_set_change,
       "Test that tc_set() calls change callback when appropriate",
       (!(err = tc_set(&ctx, "foo.bink.foo", "bar", 0)) && change == 1),
       FATAL(0),
       ("tc_set() called change callback when changing \"foo.bink.foo\""),
       ("tc_set() failed to call change callback; error code %u", err));

  if ((err = tc_find(&ctx, "foo.bink.foo", &node, 0))) /* look up a node... */
    FAIL(TEST_NAME(tc_find_node), FATAL(0), "tc_find() failed to find "
       "\"foo.bink.foo\"; error code %u", err);

  /* tc_set() must set to the default value if that's what is given */
  TEST(t_treeconf, tc_set_value_default,
       "Test that tc_set() uses the default value when that is what is given",
       (!(err = tc_set(&ctx, "foo.bink.foo", "baz", 0)) && tn_isdef(node)),
       FATAL(0),
       ("tc_set() uses default value when value is default"),
       ("tc_set() failed to use default when value is default; error code %u",
      err));

  if ((err = tc_set(&ctx, "foo.bink.foo", "bar", 0))) /* set non-default */
    FAIL(TEST_NAME(tc_set_basic), FATAL(0), "tc_set() failed to set "
       "non-default value for \"foo.bink.foo\"; error code %u", err);

  /* tc_set() must set to the default value if NULL is passed */
  TEST(t_treeconf, tc_set_null_default,
       "Test that tc_set() uses the default value when NULL is given",
       (!(err = tc_set(&ctx, "foo.bink.foo", 0, 0)) && tn_isdef(node)),
       FATAL(0),
       ("tc_set() uses default value when value is NULL"),
       ("tc_set() failed to use default value when value is NULL; error code "
      "%u", err));

  /***************************************************************************/
  /* Final tc_register test                                                  */
  /***************************************************************************/

  /* tc_register() must call change callback when creating formerly implicit
   * nodes...
   */
  change = 0; /* zero the change count... */
  TEST(t_treeconf, tc_register_change,
       "Test that tc_register() calls change callback when explicitly "
       "creating an implicit node",
       (!(err = tc_register(&ctx, "foo.implicit", "variable", 0, 0,
                      t_change, 0)) && change == 1), FATAL(0),
       ("tc_register() properly called change callback"),
       ("tc_register() failed to call change callback; error code %u", err));

  /***************************************************************************/
  /* Finally, test tc_destroy                                                */
  /***************************************************************************/

  /* Verify that tc_destroy() destroys a context... */
  TEST(t_treeconf, tc_destroy,
       "Test that tc_destroy() destroys a context",
       (!(err = tc_destroy(&ctx)) && !tx_verify(&ctx) && !tx_config(&ctx) &&
      !tx_count(&ctx)), FATAL(0),
       ("tc_destroy() properly destroyed context"),
       ("tc_destroy() failed to destroy context; error code %u", err));

  return 0;
}

---