/* Copyright (c) 2001-2004, Roger Dingledine.
 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
 * Copyright (c) 2007-2021, The Tor Project, Inc. */
/* See LICENSE for licensing information */

/*
 * Tests for confmgt.c module that we use to parse various
 * configuration/state file types.
 */

#define CONFMGT_PRIVATE
#include "orconfig.h"

#include "core/or/or.h"
#include "lib/encoding/confline.h"
#include "feature/nodelist/routerset.h"
#include "lib/confmgt/confmgt.h"
#include "test/test.h"
#include "test/log_test_helpers.h"

#include "lib/confmgt/unitparse.h"

typedef struct test_struct_t {
  uint32_t magic;
  char *s;
  char *fn;
  int pos;
  int i;
  int deprecated_int;
  uint64_t u64;
  int interval;
  int msec_interval;
  uint64_t mem;
  double dbl;
  int boolean;
  int autobool;
  time_t time;
  smartlist_t *csv;
  int csv_interval;
  config_line_t *lines;
  config_line_t *mixed_lines;
  routerset_t *routerset;
  int hidden_int;
  config_line_t *mixed_hidden_lines;

  config_line_t *extra_lines;
} test_struct_t;

static test_struct_t test_struct_t_dummy;

#define VAR(varname,conftype,member,initvalue)                          \
  CONFIG_VAR_ETYPE(test_struct_t, varname, conftype, member, 0, initvalue)
#define V(member,conftype,initvalue)            \
  VAR(#member, conftype, member, initvalue)
#define OBSOLETE(varname)                       \
  CONFIG_VAR_OBSOLETE(varname)

static const config_var_t test_vars[] = {
  V(s, STRING, "hello"),
  V(fn, FILENAME, NULL),
  V(pos, POSINT, NULL),
  V(i, INT, "-10"),
  V(deprecated_int, INT, "3"),
  V(u64, UINT64, NULL),
  V(interval, INTERVAL, "10 seconds"),
  V(msec_interval, MSEC_INTERVAL, "150 msec"),
  V(mem, MEMUNIT, "10 MB"),
  V(dbl, DOUBLE, NULL),
  V(boolean, BOOL, "0"),
  V(autobool, AUTOBOOL, "auto"),
  V(time, ISOTIME, NULL),
  V(csv, CSV, NULL),
  V(csv_interval, CSV_INTERVAL, "5 seconds"),
  V(lines, LINELIST, NULL),
  VAR("MixedLines", LINELIST_V, mixed_lines, NULL),
  VAR("LineTypeA", LINELIST_S, mixed_lines, NULL),
  VAR("LineTypeB", LINELIST_S, mixed_lines, NULL),
  OBSOLETE("obsolete"),
  {
   .member = { .name = "routerset",
               .type = CONFIG_TYPE_EXTENDED,
               .type_def = &ROUTERSET_type_defn,
               .offset = offsetof(test_struct_t, routerset),
             },
  },
  VAR("__HiddenInt", POSINT, hidden_int, "0"),
  VAR("MixedHiddenLines", LINELIST_V, mixed_hidden_lines, NULL),
  VAR("__HiddenLineA", LINELIST_S, mixed_hidden_lines, NULL),
  VAR("VisibleLineB", LINELIST_S, mixed_hidden_lines, NULL),

  END_OF_CONFIG_VARS,
};

static config_abbrev_t test_abbrevs[] = {
  { "uint", "pos", 0, 0 },
  { "float", "dbl", 0, 1 },
  { NULL, NULL, 0, 0 }
};

static config_deprecation_t test_deprecation_notes[] = {
  { "deprecated_int", "This integer is deprecated." },
  { NULL, NULL }
};

static int
test_validate_cb(const void *old_options, void *options, char **msg)
{
  (void)old_options;
  (void)msg;
  test_struct_t *ts = options;

  if (ts->i == 0xbad) {
    *msg = tor_strdup("bad value for i");
    return -1;
  }
  return 0;
}

#define TEST_MAGIC 0x1337

static const config_format_t test_fmt = {
  .size = sizeof(test_struct_t),
  .magic = {
   "test_struct_t",
   TEST_MAGIC,
   offsetof(test_struct_t, magic),
  },
  .abbrevs = test_abbrevs,
  .deprecations = test_deprecation_notes,
  .vars = test_vars,
  .legacy_validate_fn = test_validate_cb,
};

/* Make sure that config_init sets everything to the right defaults. */
static void
test_confparse_init(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = config_new(mgr);
  config_init(mgr, tst);

  // Make sure that options are initialized right. */
  tt_str_op(tst->s, OP_EQ, "hello");
  tt_ptr_op(tst->fn, OP_EQ, NULL);
  tt_int_op(tst->pos, OP_EQ, 0);
  tt_int_op(tst->i, OP_EQ, -10);
  tt_int_op(tst->deprecated_int, OP_EQ, 3);
  tt_u64_op(tst->u64, OP_EQ, 0);
  tt_int_op(tst->interval, OP_EQ, 10);
  tt_int_op(tst->msec_interval, OP_EQ, 150);
  tt_u64_op(tst->mem, OP_EQ, 10 * 1024 * 1024);
  tt_double_op(tst->dbl, OP_LT, .0000000001);
  tt_double_op(tst->dbl, OP_GT, -0.0000000001);
  tt_int_op(tst->boolean, OP_EQ, 0);
  tt_int_op(tst->autobool, OP_EQ, -1);
  tt_i64_op(tst->time, OP_EQ, 0);
  tt_ptr_op(tst->csv, OP_EQ, NULL);
  tt_int_op(tst->csv_interval, OP_EQ, 5);
  tt_ptr_op(tst->lines, OP_EQ, NULL);
  tt_ptr_op(tst->mixed_lines, OP_EQ, NULL);
  tt_int_op(tst->hidden_int, OP_EQ, 0);

 done:
  config_free(mgr, tst);
  config_mgr_free(mgr);
}

static const char simple_settings[] =
      "s this is a \n"
      "fn /simple/test of the\n"
      "uint 77\n" // this is an abbrev
      "i 3\n"
      "u64   1000000000000  \n"
      "interval 5 minutes \n"
      "msec_interval 5 minutes \n"
      "mem 10\n"
      "dbl 6.060842\n"
      "BOOLEAN 1\n"
      "aUtObOOl 0\n"
      "time 2019-06-14 13:58:51\n"
      "csv configuration, parsing  , system  \n"
      "csv_interval 10 seconds, 5 seconds, 10 hours\n"
      "lines hello\n"
      "LINES world\n"
      "linetypea i d\n"
      "linetypeb i c\n"
      "routerset $FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n"
      "__hiddenint 11\n"
      "__hiddenlineA XYZ\n"
      "visiblelineB ABC\n";

/* Return a configuration object set up from simple_settings above. */
static test_struct_t *
get_simple_config(const config_mgr_t *mgr)
{
  test_struct_t *result = NULL;
  test_struct_t *tst = config_new(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines(simple_settings, &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);

  result = tst;
  tst = NULL; // prevent free
 done:
  tor_free(msg);
  config_free_lines(lines);
  config_free(mgr, tst);
  return result;
}

/* Make sure that config_assign can parse things. */
static void
test_confparse_assign_simple(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);

  tt_str_op(tst->s, OP_EQ, "this is a");
  tt_str_op(tst->fn, OP_EQ, "/simple/test of the");
  tt_int_op(tst->pos, OP_EQ, 77);
  tt_int_op(tst->i, OP_EQ, 3);
  tt_int_op(tst->deprecated_int, OP_EQ, 3);
  tt_u64_op(tst->u64, OP_EQ, UINT64_C(1000000000000));
  tt_int_op(tst->interval, OP_EQ, 5 * 60);
  tt_int_op(tst->msec_interval, OP_EQ, 5 * 60 * 1000);
  tt_u64_op(tst->mem, OP_EQ, 10);
  tt_double_op(tst->dbl, OP_LT, 6.060843);
  tt_double_op(tst->dbl, OP_GT, 6.060841);
  tt_int_op(tst->boolean, OP_EQ, 1);
  tt_int_op(tst->autobool, OP_EQ, 0);
  tt_i64_op(tst->time, OP_EQ, 1560520731);
  tt_ptr_op(tst->csv, OP_NE, NULL);
  tt_int_op(smartlist_len(tst->csv), OP_EQ, 3);
  tt_str_op(smartlist_get(tst->csv, 0), OP_EQ, "configuration");
  tt_str_op(smartlist_get(tst->csv, 1), OP_EQ, "parsing");
  tt_str_op(smartlist_get(tst->csv, 2), OP_EQ, "system");
  tt_int_op(tst->csv_interval, OP_EQ, 10);
  tt_int_op(tst->hidden_int, OP_EQ, 11);

  tt_assert(tst->lines);
  tt_str_op(tst->lines->key, OP_EQ, "lines");
  tt_str_op(tst->lines->value, OP_EQ, "hello");
  tt_assert(tst->lines->next);
  tt_str_op(tst->lines->next->key, OP_EQ, "lines");
  tt_str_op(tst->lines->next->value, OP_EQ, "world");
  tt_assert(!tst->lines->next->next);

  tt_assert(tst->mixed_lines);
  tt_str_op(tst->mixed_lines->key, OP_EQ, "LineTypeA");
  tt_str_op(tst->mixed_lines->value, OP_EQ, "i d");
  tt_assert(tst->mixed_lines->next);
  tt_str_op(tst->mixed_lines->next->key, OP_EQ, "LineTypeB");
  tt_str_op(tst->mixed_lines->next->value, OP_EQ, "i c");
  tt_assert(!tst->mixed_lines->next->next);

  tt_assert(tst->mixed_hidden_lines);
  tt_str_op(tst->mixed_hidden_lines->key, OP_EQ, "__HiddenLineA");
  tt_str_op(tst->mixed_hidden_lines->value, OP_EQ, "XYZ");
  tt_assert(tst->mixed_hidden_lines->next);
  tt_str_op(tst->mixed_hidden_lines->next->key, OP_EQ, "VisibleLineB");
  tt_str_op(tst->mixed_hidden_lines->next->value, OP_EQ, "ABC");
  tt_assert(!tst->mixed_hidden_lines->next->next);

  tt_assert(config_check_ok(mgr, tst, LOG_ERR));

 done:
  config_free(mgr, tst);
  config_mgr_free(mgr);
}

/* Try to assign to an obsolete option, and make sure we get a warning. */
static void
test_confparse_assign_obsolete(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines("obsolete option here",
                           &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  expect_single_log_msg_containing("Skipping obsolete configuration option");

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Try to assign to an deprecated option, and make sure we get a warning
 * but the assignment works anyway. */
static void
test_confparse_assign_deprecated(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines("deprecated_int 7",
                           &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, CAL_WARN_DEPRECATIONS, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  expect_single_log_msg_containing("This integer is deprecated.");

  tt_int_op(tst->deprecated_int, OP_EQ, 7);

  tt_assert(config_check_ok(mgr, tst, LOG_ERR));

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Try to re-assign an option name that has been deprecated in favor of
 * another. */
static void
test_confparse_assign_replaced(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines("float 1000\n", &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, CAL_WARN_DEPRECATIONS, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  expect_single_log_msg_containing("use 'dbl' instead.");

  tt_double_op(tst->dbl, OP_GT, 999.999);
  tt_double_op(tst->dbl, OP_LT, 1000.001);

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Try to set a linelist value with no option. */
static void
test_confparse_assign_emptystring(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines("lines\n", &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  expect_single_log_msg_containing("has no value");

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Try to set a the same option twice; make sure we get a warning. */
static void
test_confparse_assign_twice(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines("pos 10\n"
                           "pos 99\n", &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  expect_single_log_msg_containing("used more than once");

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

typedef struct badval_test_t {
  const char *cfg;
  const char *expect_msg;
} badval_test_t;

/* Try to set an option and make sure that we get a failure and an expected
 * warning. */
static void
test_confparse_assign_badval(void *arg)
{
  const badval_test_t *bt = arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  config_init(mgr, tst);

  int r = config_get_lines(bt->cfg, &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  setup_capture_of_logs(LOG_WARN);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_LT, 0);
  tt_ptr_op(msg, OP_NE, NULL);
  if (! strstr(msg, bt->expect_msg)) {
    TT_DIE(("'%s' did not contain '%s'" , msg, bt->expect_msg));
  }

 done:
  teardown_capture_of_logs();
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Various arguments for badval test.
 *
 * Note that the expected warnings here are _very_ truncated, since we
 * are writing these tests before a refactoring that we expect will
 * change them.
 */
static const badval_test_t bv_notint = { "pos X\n", "malformed" };
static const badval_test_t bv_negint = { "pos -10\n", "out of bounds" };
static const badval_test_t bv_badu64 = { "u64 u64\n", "malformed" };
static const badval_test_t bv_dbl1 = { "dbl xxx\n", "Could not convert" };
static const badval_test_t bv_dbl2 = { "dbl 1.0 xx\n", "Could not convert" };
static const badval_test_t bv_dbl3 = {
   "dbl 1e-10000\n", "too small to express" };
static const badval_test_t bv_dbl4 = {
   "dbl 1e1000\n", "too large to express" };
static const badval_test_t bv_dbl5 = {
   "dbl -1e-10000\n", "too small to express" };
static const badval_test_t bv_dbl6 = {
   "dbl -1e1000\n", "too large to express" };
static const badval_test_t bv_badcsvi1 =
  { "csv_interval 10 wl\n", "malformed" };
static const badval_test_t bv_badcsvi2 =
  { "csv_interval cl,10\n", "malformed" };
static const badval_test_t bv_nonoption = { "fnord 10\n", "Unknown option" };
static const badval_test_t bv_badmem = { "mem 3 trits\n", "malformed" };
static const badval_test_t bv_badbool = { "boolean 7\n", "Unrecognized value"};
static const badval_test_t bv_badabool =
  { "autobool 7\n", "Unrecognized value" };
static const badval_test_t bv_badtime = { "time lunchtime\n", "Invalid time" };
static const badval_test_t bv_virt = { "MixedLines 7\n", "virtual option" };
static const badval_test_t bv_rs = { "Routerset 2.2.2.2.2\n", "Invalid" };
static const badval_test_t bv_big_interval =
  { "interval 1000 months", "too large" };

/* Try config_dump(), and make sure it behaves correctly */
static void
test_confparse_dump(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  char *dumped = NULL;

  /* Minimal version. */
  dumped = config_dump(mgr, NULL, tst, 1, 0);
  tt_str_op(dumped, OP_EQ,
            "autobool 0\n"
            "boolean 1\n"
            "csv configuration,parsing,system\n"
            "csv_interval 10\n"
            "dbl 6.060842\n"
            "fn /simple/test of the\n"
            "i 3\n"
            "interval 300\n"
            "lines hello\n"
            "lines world\n"
            "mem 10\n"
            "VisibleLineB ABC\n"
            "LineTypeA i d\n"
            "LineTypeB i c\n"
            "msec_interval 300000\n"
            "pos 77\n"
            "routerset $FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n"
            "s this is a\n"
            "time 2019-06-14 13:58:51\n"
            "u64 1000000000000\n");

  tor_free(dumped);
  dumped = config_dump(mgr, NULL, tst, 0, 0);
  tt_str_op(dumped, OP_EQ,
            "autobool 0\n"
            "boolean 1\n"
            "csv configuration,parsing,system\n"
            "csv_interval 10\n"
            "dbl 6.060842\n"
            "deprecated_int 3\n"
            "fn /simple/test of the\n"
            "i 3\n"
            "interval 300\n"
            "lines hello\n"
            "lines world\n"
            "mem 10\n"
            "VisibleLineB ABC\n"
            "LineTypeA i d\n"
            "LineTypeB i c\n"
            "msec_interval 300000\n"
            "pos 77\n"
            "routerset $FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n"
            "s this is a\n"
            "time 2019-06-14 13:58:51\n"
            "u64 1000000000000\n");

  /* commented */
  tor_free(dumped);
  dumped = config_dump(mgr, NULL, tst, 0, 1);
  tt_str_op(dumped, OP_EQ,
            "autobool 0\n"
            "boolean 1\n"
            "csv configuration,parsing,system\n"
            "csv_interval 10\n"
            "dbl 6.060842\n"
            "# deprecated_int 3\n"
            "fn /simple/test of the\n"
            "i 3\n"
            "interval 300\n"
            "lines hello\n"
            "lines world\n"
            "mem 10\n"
            "VisibleLineB ABC\n"
            "LineTypeA i d\n"
            "LineTypeB i c\n"
            "msec_interval 300000\n"
            "pos 77\n"
            "routerset $FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n"
            "s this is a\n"
            "time 2019-06-14 13:58:51\n"
            "u64 1000000000000\n");

 done:
  config_free(mgr, tst);
  tor_free(dumped);
  config_mgr_free(mgr);
}

/* Try confparse_reset_line(), and make sure it behaves correctly */
static void
test_confparse_reset(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);

  config_reset_line(mgr, tst, "interval", 0);
  tt_int_op(tst->interval, OP_EQ, 0);

  config_reset_line(mgr, tst, "interval", 1);
  tt_int_op(tst->interval, OP_EQ, 10);

  tt_ptr_op(tst->routerset, OP_NE, NULL);
  config_reset_line(mgr, tst, "routerset", 0);
  tt_ptr_op(tst->routerset, OP_EQ, NULL);

 done:
  config_free(mgr, tst);
  config_mgr_free(mgr);
}

/* Try setting options a second time on a config object, and make sure
 * it behaves correctly. */
static void
test_confparse_reassign(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL, *rs = NULL;

  int r = config_get_lines(
         "s eleven\n"
         "i 12\n"
         "lines 13\n"
         "csv 14,15\n"
         "routerset 127.0.0.1\n",
         &lines, 0);
  r = config_assign(mgr, tst,lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);

  tt_str_op(tst->s, OP_EQ, "eleven");
  tt_str_op(tst->fn, OP_EQ, "/simple/test of the"); // unchanged
  tt_int_op(tst->pos, OP_EQ, 77); // unchanged
  tt_int_op(tst->i, OP_EQ, 12);
  tt_ptr_op(tst->lines, OP_NE, NULL);
  tt_str_op(tst->lines->key, OP_EQ, "lines");
  tt_str_op(tst->lines->value, OP_EQ, "13");
  tt_ptr_op(tst->lines->next, OP_EQ, NULL);
  tt_int_op(smartlist_len(tst->csv), OP_EQ, 2);
  tt_str_op(smartlist_get(tst->csv, 0), OP_EQ, "14");
  tt_str_op(smartlist_get(tst->csv, 1), OP_EQ, "15");

  rs = routerset_to_string(tst->routerset);
  tt_str_op(rs, OP_EQ, "127.0.0.1");

  // Try again with the CLEAR_FIRST and USE_DEFAULTS flags
  r = config_assign(mgr, tst, lines,
                    CAL_CLEAR_FIRST|CAL_USE_DEFAULTS, &msg);
  tt_int_op(r, OP_EQ, 0);

  tt_ptr_op(msg, OP_EQ, NULL);
  tt_str_op(tst->s, OP_EQ, "eleven");
  // tt_ptr_op(tst->fn, OP_EQ, NULL); //XXXX why is this not cleared?
  // tt_int_op(tst->pos, OP_EQ, 0); //XXXX why is this not cleared?
  tt_int_op(tst->i, OP_EQ, 12);

 done:
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  tor_free(rs);
  config_mgr_free(mgr);
}

/* Try setting options a second time on a config object, using the +foo
 * linelist-extending syntax. */
static void
test_confparse_reassign_extend(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL;

  int r = config_get_lines(
         "+lines 13\n",
         &lines, 1); // allow extended format.
  tt_int_op(r, OP_EQ, 0);
  r = config_assign(mgr, tst,lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);

  tt_assert(tst->lines);
  tt_str_op(tst->lines->key, OP_EQ, "lines");
  tt_str_op(tst->lines->value, OP_EQ, "hello");
  tt_assert(tst->lines->next);
  tt_str_op(tst->lines->next->key, OP_EQ, "lines");
  tt_str_op(tst->lines->next->value, OP_EQ, "world");
  tt_assert(tst->lines->next->next);
  tt_str_op(tst->lines->next->next->key, OP_EQ, "lines");
  tt_str_op(tst->lines->next->next->value, OP_EQ, "13");
  tt_assert(tst->lines->next->next->next == NULL);
  config_free_lines(lines);

  r = config_get_lines(
         "/lines\n",
         &lines, 1); // allow extended format.
  tt_int_op(r, OP_EQ, 0);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  tt_assert(tst->lines == NULL);
  config_free_lines(lines);

  config_free(mgr, tst);
  tst = get_simple_config(mgr);
  r = config_get_lines(
         "/lines away!\n",
         &lines, 1); // allow extended format.
  tt_int_op(r, OP_EQ, 0);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);
  tt_assert(tst->lines == NULL);

 done:
  config_free(mgr, tst);
  config_free_lines(lines);
  tor_free(msg);
  config_mgr_free(mgr);
}

/* Test out confparse_get_assigned(). */
static void
test_confparse_get_assigned(void *arg)
{
  (void)arg;

  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = get_simple_config(mgr);
  config_line_t *lines = NULL;

  lines = config_get_assigned_option(mgr, tst, "I", 1);
  tt_assert(lines);
  tt_str_op(lines->key, OP_EQ, "i");
  tt_str_op(lines->value, OP_EQ, "3");
  tt_assert(lines->next == NULL);
  config_free_lines(lines);

  lines = config_get_assigned_option(mgr, tst, "s", 1);
  tt_assert(lines);
  tt_str_op(lines->key, OP_EQ, "s");
  tt_str_op(lines->value, OP_EQ, "this is a");
  tt_assert(lines->next == NULL);
  config_free_lines(lines);

  lines = config_get_assigned_option(mgr, tst, "obsolete", 1);
  tt_assert(!lines);

  lines = config_get_assigned_option(mgr, tst, "nonesuch", 1);
  tt_assert(!lines);

  lines = config_get_assigned_option(mgr, tst, "mixedlines", 1);
  tt_assert(lines);
  tt_str_op(lines->key, OP_EQ, "LineTypeA");
  tt_str_op(lines->value, OP_EQ, "i d");
  tt_assert(lines->next);
  tt_str_op(lines->next->key, OP_EQ, "LineTypeB");
  tt_str_op(lines->next->value, OP_EQ, "i c");
  tt_assert(lines->next->next == NULL);
  config_free_lines(lines);

  lines = config_get_assigned_option(mgr, tst, "linetypeb", 1);
  tt_assert(lines);
  tt_str_op(lines->key, OP_EQ, "LineTypeB");
  tt_str_op(lines->value, OP_EQ, "i c");
  tt_assert(lines->next == NULL);
  config_free_lines(lines);

  tor_free(tst->s);
  tst->s = tor_strdup("Hello\nWorld");
  lines = config_get_assigned_option(mgr, tst, "s", 1);
  tt_assert(lines);
  tt_str_op(lines->key, OP_EQ, "s");
  tt_str_op(lines->value, OP_EQ, "\"Hello\\nWorld\"");
  tt_assert(lines->next == NULL);
  config_free_lines(lines);

 done:
  config_free(mgr, tst);
  config_free_lines(lines);
  config_mgr_free(mgr);
}

/* Another variant, which accepts and stores unrecognized lines.*/
#define ETEST_MAGIC 13371337

static struct_member_t extra = {
  .name = "__extra",
  .type = CONFIG_TYPE_LINELIST,
  .offset = offsetof(test_struct_t, extra_lines),
};

static config_format_t etest_fmt = {
  .size = sizeof(test_struct_t),
  .magic = {
   "test_struct_t (with extra lines)",
   ETEST_MAGIC,
   offsetof(test_struct_t, magic),
  },
  .abbrevs = test_abbrevs,
  .deprecations = test_deprecation_notes,
  .vars = test_vars,
  .legacy_validate_fn = test_validate_cb,
  .extra = &extra,
};

/* Try out the feature where we can store unrecognized lines and dump them
 * again.  (State files use this.) */
static void
test_confparse_extra_lines(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&etest_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = config_new(mgr);
  config_line_t *lines = NULL;
  char *msg = NULL, *dump = NULL;

  config_init(mgr, tst);

  int r = config_get_lines(
      "unknotty addita\n"
      "pos 99\n"
      "wombat knish\n", &lines, 0);
  tt_int_op(r, OP_EQ, 0);
  r = config_assign(mgr, tst, lines, 0, &msg);
  tt_int_op(r, OP_EQ, 0);
  tt_ptr_op(msg, OP_EQ, NULL);

  tt_assert(tst->extra_lines);

  dump = config_dump(mgr, NULL, tst, 1, 0);
  tt_str_op(dump, OP_EQ,
      "pos 99\n"
      "unknotty addita\n"
      "wombat knish\n");

 done:
  tor_free(msg);
  tor_free(dump);
  config_free_lines(lines);
  config_free(mgr, tst);
  config_mgr_free(mgr);
}

static void
test_confparse_unitparse(void *args)
{
  (void)args;
  /* spot-check a few memunit values. */
  int ok = 3;
  tt_u64_op(config_parse_memunit("100 MB", &ok), OP_EQ, 100<<20);
  tt_assert(ok);
  tt_u64_op(config_parse_memunit("100 TB", &ok), OP_EQ, UINT64_C(100)<<40);
  tt_assert(ok);
  // This is a floating-point value, but note that 1.5 can be represented
  // precisely.
  tt_u64_op(config_parse_memunit("1.5 MB", &ok), OP_EQ, 3<<19);
  tt_assert(ok);

  /* Try some good intervals and msec intervals */
  tt_int_op(config_parse_interval("2 days", &ok), OP_EQ, 48*3600);
  tt_assert(ok);
  tt_int_op(config_parse_interval("1.5 hour", &ok), OP_EQ, 5400);
  tt_assert(ok);
  tt_u64_op(config_parse_interval("1 minute", &ok), OP_EQ, 60);
  tt_assert(ok);
  tt_int_op(config_parse_msec_interval("2 days", &ok), OP_EQ, 48*3600*1000);
  tt_assert(ok);
  tt_int_op(config_parse_msec_interval("10 msec", &ok), OP_EQ, 10);
  tt_assert(ok);

  /* Try a couple of unitless values. */
  tt_int_op(config_parse_interval("10", &ok), OP_EQ, 10);
  tt_assert(ok);
  tt_u64_op(config_parse_interval("15.0", &ok), OP_EQ, 15);
  tt_assert(ok);

  /* u64 overflow */
  tt_u64_op(config_parse_memunit("20000000 TB", &ok), OP_EQ, 0);
  tt_assert(!ok);
  // This test fails the double check as the float representing 15000000.5 TB
  // is greater than (double) INT64_MAX
  tt_u64_op(config_parse_memunit("15000000.5 TB", &ok), OP_EQ, 0);
  tt_assert(!ok);
  // 8388608.1 TB passes double check because it falls in the same float
  // value as (double)INT64_MAX (which is 2^63) due to precision.
  // But will fail the int check because the unsigned representation of
  // the float, which is 2^63, is strictly greater than INT64_MAX (2^63-1)
  tt_u64_op(config_parse_memunit("8388608.1 TB", &ok), OP_EQ, 0);
  tt_assert(!ok);

  /* negative float */
  tt_u64_op(config_parse_memunit("-1.5 GB", &ok), OP_EQ, 0);
  tt_assert(!ok);

  /* i32 overflow */
  tt_int_op(config_parse_interval("1000 months", &ok), OP_EQ, -1);
  tt_assert(!ok);
  tt_int_op(config_parse_msec_interval("4 weeks", &ok), OP_EQ, -1);
  tt_assert(!ok);

  /* bad units */
  tt_u64_op(config_parse_memunit("7 nybbles", &ok), OP_EQ, 0);
  tt_assert(!ok);
  // XXXX these next two should return -1 according to the documentation.
  tt_int_op(config_parse_interval("7 cowznofski", &ok), OP_EQ, 0);
  tt_assert(!ok);
  tt_int_op(config_parse_msec_interval("1 kalpa", &ok), OP_EQ, 0);
  tt_assert(!ok);

 done:
  ;
}

static void
test_confparse_check_ok_fail(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  config_mgr_freeze(mgr);
  test_struct_t *tst = config_new(mgr);
  tst->pos = -10;
  tt_assert(! config_check_ok(mgr, tst, LOG_INFO));

 done:
  config_free(mgr, tst);
  config_mgr_free(mgr);
}

static void
test_confparse_list_vars(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  smartlist_t *vars = config_mgr_list_vars(mgr);
  smartlist_t *varnames = smartlist_new();
  char *joined = NULL;

  tt_assert(vars);
  SMARTLIST_FOREACH(vars, config_var_t *, cv,
                    smartlist_add(varnames, (void*)cv->member.name));
  smartlist_sort_strings(varnames);
  joined = smartlist_join_strings(varnames, "::", 0, NULL);
  tt_str_op(joined, OP_EQ,
            "LineTypeA::"
            "LineTypeB::"
            "MixedHiddenLines::"
            "MixedLines::"
            "VisibleLineB::"
            "__HiddenInt::"
            "__HiddenLineA::"
            "autobool::"
            "boolean::"
            "csv::"
            "csv_interval::"
            "dbl::"
            "deprecated_int::"
            "fn::"
            "i::"
            "interval::"
            "lines::"
            "mem::"
            "msec_interval::"
            "obsolete::"
            "pos::"
            "routerset::"
            "s::"
            "time::"
            "u64");

 done:
  tor_free(joined);
  smartlist_free(varnames);
  smartlist_free(vars);
  config_mgr_free(mgr);
}

static void
test_confparse_list_deprecated(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);
  smartlist_t *vars = config_mgr_list_deprecated_vars(mgr);
  char *joined = NULL;

  tt_assert(vars);
  smartlist_sort_strings(vars);
  joined = smartlist_join_strings(vars, "::", 0, NULL);

  tt_str_op(joined, OP_EQ, "deprecated_int");

 done:
  tor_free(joined);
  smartlist_free(vars);
  config_mgr_free(mgr);
}

static void
test_confparse_find_option_name(void *arg)
{
  (void)arg;
  config_mgr_t *mgr = config_mgr_new(&test_fmt);

  // exact match
  tt_str_op(config_find_option_name(mgr, "u64"), OP_EQ, "u64");
  // case-insensitive match
  tt_str_op(config_find_option_name(mgr, "S"), OP_EQ, "s");
  tt_str_op(config_find_option_name(mgr, "linetypea"), OP_EQ, "LineTypeA");
  // prefix match
  tt_str_op(config_find_option_name(mgr, "deprec"), OP_EQ, "deprecated_int");
  // explicit abbreviation
  tt_str_op(config_find_option_name(mgr, "uint"), OP_EQ, "pos");
  tt_str_op(config_find_option_name(mgr, "UINT"), OP_EQ, "pos");
  // no match
  tt_ptr_op(config_find_option_name(mgr, "absent"), OP_EQ, NULL);

 done:
  config_mgr_free(mgr);
}

#ifndef COCCI
#define CONFPARSE_TEST(name, flags)                          \
  { #name, test_confparse_ ## name, flags, NULL, NULL }

#define BADVAL_TEST(name)                               \
  { "badval_" #name, test_confparse_assign_badval, 0,   \
      &passthrough_setup, (void*)&bv_ ## name }
#endif /* !defined(COCCI) */

struct testcase_t confparse_tests[] = {
  CONFPARSE_TEST(init, 0),
  CONFPARSE_TEST(assign_simple, 0),
  CONFPARSE_TEST(assign_obsolete, 0),
  CONFPARSE_TEST(assign_deprecated, 0),
  CONFPARSE_TEST(assign_replaced, 0),
  CONFPARSE_TEST(assign_emptystring, 0),
  CONFPARSE_TEST(assign_twice, 0),
  BADVAL_TEST(notint),
  BADVAL_TEST(negint),
  BADVAL_TEST(badu64),
  BADVAL_TEST(dbl1),
  BADVAL_TEST(dbl2),
  BADVAL_TEST(dbl3),
  BADVAL_TEST(dbl4),
  BADVAL_TEST(dbl5),
  BADVAL_TEST(dbl6),
  BADVAL_TEST(badcsvi1),
  BADVAL_TEST(badcsvi2),
  BADVAL_TEST(nonoption),
  BADVAL_TEST(badmem),
  BADVAL_TEST(badbool),
  BADVAL_TEST(badabool),
  BADVAL_TEST(badtime),
  BADVAL_TEST(virt),
  BADVAL_TEST(rs),
  BADVAL_TEST(big_interval),
  CONFPARSE_TEST(dump, 0),
  CONFPARSE_TEST(reset, 0),
  CONFPARSE_TEST(reassign, 0),
  CONFPARSE_TEST(reassign_extend, 0),
  CONFPARSE_TEST(get_assigned, 0),
  CONFPARSE_TEST(extra_lines, 0),
  CONFPARSE_TEST(unitparse, 0),
  CONFPARSE_TEST(check_ok_fail, 0),
  CONFPARSE_TEST(list_vars, 0),
  CONFPARSE_TEST(list_deprecated, 0),
  CONFPARSE_TEST(find_option_name, 0),
  END_OF_TESTCASES
};