pairmove_tests.c

Go to the documentation of this file.

/*
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library 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
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/** Tests for `radius_pairmove()`
 *
 * @file src/lib/server/pairmove_tests.c
 *
 * `radius_pairmove()` merges the pairs of the `from` list into the `to` list,
 * and applies the operator of each pair in the `from` list.  These tests
 * record the behaviour of `radius_pairmove()`.  A developer who rewrites the
 * function runs the tests to check that the behaviour is unchanged.
 *
 * Each test writes a list as short text, for example `s0=a i0+=5`.  Each
 * entry has a name, an operator, and a value:
 *
 *      s0, s1, s2      `Test-String-0`, `Test-String-1`, `Test-String-2`
 *      i0, i1          `Test-Uint32-0`, `Test-Uint32-1`
 *      p4, p6          `Test-IPv4-Prefix`, `Test-IPv6-Prefix`
 *      un, up          `Test-User-Name`, `Test-User-Password`
 *
 * Each test renders the merged `to` list in the same text form, and compares
 * the result with the expected text.  Each case runs against the request list,
 * the reply list, and the control list of a request.  After the merge, the test
 * frees the `to` list and checks that the number of talloc blocks under the
 * request equals the number before the merge.  The check catches a leak of
 * pairs, or of the temporary arrays that `radius_pairmove()` allocates.
 *
 * @copyright 2026 The FreeRADIUS server project
 */
static void test_init(void);
#define TEST_GLOBAL_INIT test_init()
 
#include <freeradius-devel/util/test/acutest_common_init.h>
#include <freeradius-devel/util/test/acutest_helpers.h>
#include <freeradius-devel/util/dict_test.h>
 
#include <freeradius-devel/server/pairmove.h>
#include <freeradius-devel/server/request.h>
#include <freeradius-devel/util/conf.h>
#include <freeradius-devel/util/pair.h>
 
static TALLOC_CTX       *autofree;
static fr_dict_t        *test_dict;
 
/*
 *      The text form of a list uses these short names for attributes.
 *      The `da` field is filled in by `fr_dict_test_init()`.
 */
static struct {
        char const              *name;
        fr_dict_attr_t const    *da;
} attr_names[] = {
        { .name = "s0" }, { .name = "s1" }, { .name = "s2" },
        { .name = "i0" }, { .name = "i1" },
        { .name = "p4" }, { .name = "p6" },
        { .name = "un" }, { .name = "up" },
};
 
static fr_dict_test_attr_t const test_attrs[] = {
        { .attr = (fr_dict_test_attr_number_t) 1, .da = &attr_names[0].da, .name = "Test-String-0", .type = FR_TYPE_STRING },
        { .attr = (fr_dict_test_attr_number_t) 2, .da = &attr_names[1].da, .name = "Test-String-1", .type = FR_TYPE_STRING },
        { .attr = (fr_dict_test_attr_number_t) 3, .da = &attr_names[2].da, .name = "Test-String-2", .type = FR_TYPE_STRING },
        { .attr = (fr_dict_test_attr_number_t) 4, .da = &attr_names[3].da, .name = "Test-Uint32-0", .type = FR_TYPE_UINT32 },
        { .attr = (fr_dict_test_attr_number_t) 5, .da = &attr_names[4].da, .name = "Test-Uint32-1", .type = FR_TYPE_UINT32 },
        { .attr = (fr_dict_test_attr_number_t) 6, .da = &attr_names[5].da, .name = "Test-IPv4-Prefix", .type = FR_TYPE_IPV4_PREFIX },
        { .attr = (fr_dict_test_attr_number_t) 7, .da = &attr_names[6].da, .name = "Test-IPv6-Prefix", .type = FR_TYPE_IPV6_PREFIX },
        { .attr = (fr_dict_test_attr_number_t) 8, .da = &attr_names[7].da, .name = "Test-User-Name", .type = FR_TYPE_STRING },
        { .attr = (fr_dict_test_attr_number_t) 9, .da = &attr_names[8].da, .name = "Test-User-Password", .type = FR_TYPE_STRING },
        { .attr = FR_TEST_ATTR_INVALID }
};
 
/** Global initialisation
 */
static void test_init(void)
{
        autofree = talloc_autofree_context();
        if (!autofree) {
        error:
                fr_perror("pairmove_tests");
                fr_exit_now(EXIT_FAILURE);
        }
 
        /*
         *      Mismatch between the binary and the libraries it depends on
         */
        if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) goto error;
 
        if (fr_dict_test_init(autofree, &test_dict, test_attrs) < 0) goto error;
 
        if (request_global_init() < 0) goto error;
}
 
/*
 *      `list_alloc()` uses the first operator in this table that matches the
 *      text.  An operator that is the prefix of another operator, such as '='
 *      in '==', must come after the longer operator.
 */
static struct {
        char const      *str;
        fr_token_t      op;
} const op_names[] = {
        { ":=", T_OP_SET },
        { "+=", T_OP_ADD_EQ },
        { "-=", T_OP_SUB_EQ },
        { "==", T_OP_CMP_EQ },
        { "<=", T_OP_LE },
        { ">=", T_OP_GE },
        { "!*", T_OP_CMP_FALSE },
        { "^=", T_OP_PREPEND },
        { "=", T_OP_EQ },
};
 
/** Build a list of pairs from the text in `spec`
 *
 * `list_alloc()` allocates the pairs in `ctx`.  Because the '!*' operator
 * does not take a value, `list_alloc()` gives the pair an empty string, or
 * zero for an integer.
 */
static void list_alloc(TALLOC_CTX *ctx, fr_pair_list_t *list, char const *spec)
{
        char const      *p = spec;
 
        while (*p) {
                char                    name[3];
                char                    value[64];
                fr_dict_attr_t const    *da = NULL;
                fr_token_t              op = T_INVALID;
                size_t                  i, len;
                fr_pair_t               *vp;
 
                while (*p == ' ') p++;
                if (!*p) break;
 
                TEST_ASSERT(p[0] && p[1]);
                name[0] = p[0];
                name[1] = p[1];
                name[2] = '\0';
                p += 2;
 
                for (i = 0; i < NUM_ELEMENTS(attr_names); i++) {
                        if (strcmp(attr_names[i].name, name) == 0) {
                                da = attr_names[i].da;
                                break;
                        }
                }
                TEST_ASSERT(da != NULL);
 
                for (i = 0; i < NUM_ELEMENTS(op_names); i++) {
                        len = strlen(op_names[i].str);
                        if (strncmp(p, op_names[i].str, len) == 0) {
                                op = op_names[i].op;
                                p += len;
                                break;
                        }
                }
                TEST_ASSERT(op != T_INVALID);
 
                len = strcspn(p, " ");
                TEST_ASSERT(len < sizeof(value));
                memcpy(value, p, len);
                value[len] = '\0';
                p += len;
 
                if ((len == 0) && (name[0] == 'i')) strcpy(value, "0");
 
                vp = fr_pair_afrom_da(ctx, da);
                TEST_ASSERT(vp != NULL);
#ifdef STATIC_ANALYZER
                if (!vp) _exit(1);
#endif
 
                TEST_ASSERT(fr_pair_value_from_str(vp, value, strlen(value), NULL, false) == 0);
 
                vp->op = op;
                fr_pair_append(list, vp);
        }
}
 
/** Render a list in the text form that `list_alloc()` accepts
 *
 * Because `list_str()` omits the '=' operator, a result pair that still has
 * an operator from the `from` list shows the operator in the output.
 */
static char const *list_str(fr_pair_list_t const *list)
{
        static char     buffer[4096];
        fr_sbuff_t      out = FR_SBUFF_OUT(buffer, sizeof(buffer));
 
        buffer[0] = '\0';
 
        fr_pair_list_foreach(list, vp) {
                char const      *name = NULL;
                size_t          i;
 
                for (i = 0; i < NUM_ELEMENTS(attr_names); i++) {
                        if (attr_names[i].da == vp->da) {
                                name = attr_names[i].name;
                                break;
                        }
                }
                if (!name) name = vp->da->name;
 
                if (fr_sbuff_used(&out) > 0) (void) fr_sbuff_in_char(&out, ' ');
                (void) fr_sbuff_in_strcpy(&out, name);
                if (vp->op != T_OP_EQ) {
                        (void) fr_sbuff_in_strcpy(&out, fr_tokens[vp->op]);
                } else {
                        (void) fr_sbuff_in_char(&out, '=');
                }
                (void) fr_value_box_print(&out, &vp->data, NULL);
        }
 
        return buffer;
}
 
typedef enum {
        LIST_REQUEST = 0,
        LIST_REPLY,
        LIST_CONTROL,
        LIST_NUM
} list_target_t;
 
static char const *list_target_names[LIST_NUM] = { "request", "reply", "control" };
 
/** Make a request with empty pair lists
 */
static request_t *request_make(void)
{
        request_t *request;
 
        request = request_local_alloc_external(autofree, (&(request_init_args_t){ .namespace = test_dict }));
        TEST_ASSERT(request != NULL);
 
        request->packet = fr_packet_alloc(request, false);
        TEST_ASSERT(request->packet != NULL);
 
        request->reply = fr_packet_alloc(request, false);
        TEST_ASSERT(request->reply != NULL);
 
        return request;
}
 
/** Get the pair list and the talloc context for a target
 *
 * `list_target()` sets `*ctx` to the talloc context in which the server
 * allocates the pairs of the list.
 */
static fr_pair_list_t *list_target(TALLOC_CTX **ctx, request_t *request, list_target_t target)
{
        switch (target) {
        case LIST_REQUEST:
                *ctx = request->request_ctx;
                return &request->request_pairs;
 
        case LIST_REPLY:
                *ctx = request->reply_ctx;
                return &request->reply_pairs;
 
        default:
                *ctx = request->control_ctx;
                return &request->control_pairs;
        }
}
 
typedef struct {
        char const      *name;
        char const      *to;            //!< Text form of the `to` list before the merge.
        char const      *from;          //!< Text form of the `from` list.
        char const      *expect;        //!< Expected text form of the `to` list after the merge.
} pairmove_case_t;
 
static void pairmove_run(pairmove_case_t const *tc, list_target_t target)
{
        request_t       *request;
        TALLOC_CTX      *ctx;
        fr_pair_list_t  *to;
        fr_pair_list_t  from;
        size_t          before, after;
 
        request = request_make();
        to = list_target(&ctx, request, target);
 
        before = talloc_total_blocks(request);
 
        list_alloc(ctx, to, tc->to);
        fr_pair_list_init(&from);
        list_alloc(ctx, &from, tc->from);
 
        radius_pairmove(request, to, &from);    /* consumes `from` */
 
        TEST_CASE_("%s: %s", tc->name, list_target_names[target]);
        TEST_CHECK_STRCMP(list_str(to), tc->expect);
 
        TEST_CHECK(fr_pair_list_empty(&from));
 
        /*
         *      Each pair must be in the `to` list or freed by `radius_pairmove()`.
         *      Freeing the `to` list then returns the number of talloc blocks to the
         *      value before the merge.
         */
        fr_pair_list_free(to);
        after = talloc_total_blocks(request);
        TEST_CHECK(after == before);
        TEST_MSG("Blocks before : %zu", before);
        TEST_MSG("Blocks after  : %zu", after);
 
        talloc_free(request);
}
 
static void pairmove_run_cases(pairmove_case_t const *cases, size_t num)
{
        size_t          i;
        list_target_t   target;
 
        for (i = 0; i < num; i++) {
                for (target = LIST_REQUEST; target < LIST_NUM; target++) pairmove_run(&cases[i], target);
        }
}
 
/*
 *      The '=' operator adds an attribute to the `to` list only if the `to`
 *      list does not already have an instance of the attribute.
 */
static void test_op_eq(void)
{
        static pairmove_case_t const cases[] = {
                { "empty into empty",           "",             "",             "" },
                { "= into empty",               "",             "s0=a",         "s0=a" },
                { "= absent attribute",         "s0=a",         "s1=b",         "s0=a s1=b" },
                { "= present attribute",        "s0=a",         "s0=b",         "s0=a" },
                { "= present, others",          "s1=x s0=a",    "s0=b s2=c",    "s1=x s0=a s2=c" },
 
                /*
                 *      Because '=' checks the original `to` list only, and the original
                 *      `to` list is empty, the merge adds both `s0=a` and `s0=b`.
                 */
                { "= twice, absent",            "",             "s0=a s0=b",    "s0=a s0=b" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The ':=' operator replaces the first instance of the attribute in the
 *      `to` list.  The operator adds the attribute when the `to` list does
 *      not have an instance.
 */
static void test_op_set(void)
{
        static pairmove_case_t const cases[] = {
                { ":= into empty",              "",             "s0:=c",        "s0=c" },
                { ":= absent attribute",        "s1=x",         "s0:=c",        "s1=x s0=c" },
                { ":= replaces in place",       "s1=x s0=a i0=1", "s0:=b",      "s1=x s0=b i0=1" },
                { ":= replaces first only",     "s0=a s0=b",    "s0:=c",        "s0=c s0=b" },
 
                /*
                 *      Because the merge does not replace an instance twice, the second ':='
                 *      replaces the second instance of the attribute, or adds a new instance
                 *      when the `to` list has only one instance.
                 */
                { ":= twice, one instance",     "s0=a",         "s0:=b s0:=c",  "s0=b s0=c" },
                { ":= twice, two instances",    "s0=a s0=x",    "s0:=b s0:=c",  "s0=b s0=c" },
                { ":= thrice, two instances",   "s0=a s0=x",    "s0:=b s0:=c s0:=d", "s0=b s0=c s0=d" },
                { ":= integer",                 "i0=1",         "i0:=2",        "i0=2" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '+=' operator always adds the attribute at the end of the `to` list.
 */
static void test_op_add(void)
{
        static pairmove_case_t const cases[] = {
                { "+= into empty",              "",             "s0+=a",        "s0=a" },
                { "+= present attribute",       "s0=a",         "s0+=b",        "s0=a s0=b" },
                { "+= same value",              "s0=a",         "s0+=a",        "s0=a s0=a" },
                { "+= keeps from order",        "s0=a",         "s1+=x s2+=y s1+=z", "s0=a s1=x s2=y s1=z" },
                { "+= integer",                 "i0=1",         "i0+=2",        "i0=1 i0=2" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '^=' operator adds the attribute at the start of the `to` list.
 *
 *      The merge applies the '^=' pairs in the order of the `from` list.
 *      Because each '^=' pair goes to the start of the `to` list, a later
 *      '^=' pair comes before an earlier '^=' pair.  The result lists the '^='
 *      attributes in the reverse of the order of the `from` list.
 */
static void test_op_prepend(void)
{
        static pairmove_case_t const cases[] = {
                { "^= into empty",              "",             "s0^=a",        "s0=a" },
                { "^= one attribute",           "s0=a",         "s1^=x",        "s1=x s0=a" },
                { "^= present attribute",       "s0=a",         "s0^=b",        "s0=b s0=a" },
                { "^= two attributes",          "s0=a",         "s1^=x s2^=y",  "s2=y s1=x s0=a" },
                { "^= three attributes",        "",             "s0^=a s1^=b s2^=c", "s2=c s1=b s0=a" },
                { "^= and +=",                  "s0=a",         "s1+=x s2^=y",  "s2=y s0=a s1=x" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '-=' operator deletes every instance of the attribute from the
 *      `to` list when the value of the instance matches the value of the
 *      `from` pair.
 */
static void test_op_sub(void)
{
        static pairmove_case_t const cases[] = {
                { "-= from empty",              "",             "s0-=a",        "" },
                { "-= absent attribute",        "s1=x",         "s0-=a",        "s1=x" },
                { "-= no matching value",       "s0=a",         "s0-=b",        "s0=a" },
                { "-= matching value",          "s0=a",         "s0-=a",        "" },
                { "-= all matching values",     "s0=a s0=b s0=a", "s0-=a",      "s0=b" },
                { "-= keeps others",            "s1=x s0=a i0=1", "s0-=a",      "s1=x i0=1" },
                { "-= integer",                 "i0=1 i0=2",    "i0-=2",        "i0=1" },
                { "-= twice",                   "s0=a s0=b s0=c", "s0-=a s0-=c", "s0=b" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '!*' operator deletes every instance of the attribute from the
 *      `to` list, regardless of the value.
 */
static void test_op_cmp_false(void)
{
        static pairmove_case_t const cases[] = {
                { "!* from empty",              "",             "s0!*",         "" },
                { "!* absent attribute",        "s1=x",         "s0!*",         "s1=x" },
                { "!* one instance",            "s0=a",         "s0!*",         "" },
                { "!* all instances",           "s0=a s1=b s0=c", "s0!*",       "s1=b" },
                { "!* integer",                 "i0=1 i0=2",    "i0!*",         "" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '==' operator deletes every instance of the attribute that does
 *      not have the value of the `from` pair.  The operator keeps every
 *      instance that has the value, and does not add the attribute.
 */
static void test_op_cmp_eq(void)
{
        static pairmove_case_t const cases[] = {
                { "== from empty",              "",             "s0==a",        "" },
                { "== absent attribute",        "s1=x",         "s0==a",        "s1=x" },
                { "== matching value",          "s0=a",         "s0==a",        "s0=a" },
                { "== no matching value",       "s0=a",         "s0==b",        "" },
                { "== some matching",           "s0=a s0=b s0=a", "s0==a",      "s0=a s0=a" },
                { "== keeps others",            "s1=x s0=b",    "s0==a",        "s1=x" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '<=' operator replaces the first instance of the attribute that
 *      has a value greater than the value of the `from` pair.
 *      The '>=' operator replaces the first instance of the attribute that
 *      has a value less than the value of the `from` pair.
 */
static void test_op_le_ge(void)
{
        static pairmove_case_t const cases[] = {
                { "<= larger value",            "i0=10",        "i0<=5",        "i0=5" },
 
                /*
                 *      When the existing value already satisfies the operator, the merge
                 *      keeps the existing value and does not add the value from the `from`
                 *      list.
                 */
                { "<= equal value",             "i0=5",         "i0<=5",        "i0=5" },
                { "<= smaller value",           "i0=3",         "i0<=5",        "i0=3" },
                { "<= absent attribute",        "i1=1",         "i0<=5",        "i1=1 i0=5" },
                { "<= into empty",              "",             "i0<=5",        "i0=5" },
                { "<= replaces in place",       "i1=1 i0=10 s0=a", "i0<=5",     "i1=1 i0=5 s0=a" },
                { "<= all instances",           "i0=10 i0=20",  "i0<=5",        "i0=5 i0=20" },
 
                { ">= smaller value",           "i0=3",         "i0>=5",        "i0=5" },
                { ">= equal value",             "i0=5",         "i0>=5",        "i0=5" },
                { ">= larger value",            "i0=9",         "i0>=5",        "i0=9" },
                { ">= absent attribute",        "i1=1",         "i0>=5",        "i1=1 i0=5" },
                { ">= into empty",              "",             "i0>=5",        "i0=5" },
                { ">= replaces in place",       "i1=1 i0=3 s0=a", "i0>=5",      "i1=1 i0=5 s0=a" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '<=' and '>=' operators with prefixes.
 *
 *      `radius_pairmove()` compares the values with the '==' operator, and
 *      prefixes only compare as equal or not equal.  There is no ordering, so
 *      '<=' never replaces a prefix, and '>=' replaces a prefix whenever the
 *      prefixes are different.  This is true even when one prefix contains
 *      the other.
 */
static void test_op_le_ge_prefix(void)
{
        static pairmove_case_t const cases[] = {
                /*
                 *      IPv4.
                 */
                { "<= ipv4 prefix, inside",     "p4=10.0.0.0/8", "p4<=10.1.0.0/16",     "p4=10.0.0.0/8" },
                { "<= ipv4 prefix, equal",      "p4=10.0.0.0/8", "p4<=10.0.0.0/8",      "p4=10.0.0.0/8" },
                { "<= ipv4 prefix, contains",   "p4=10.0.0.0/8", "p4<=0.0.0.0/0",       "p4=10.0.0.0/8" },
                { "<= ipv4 prefix, disjoint",   "p4=10.0.0.0/8", "p4<=192.168.0.0/16",  "p4=10.0.0.0/8" },
                { ">= ipv4 prefix, inside",     "p4=10.0.0.0/8", "p4>=10.1.0.0/16",     "p4=10.1.0.0/16" },
                { ">= ipv4 prefix, equal",      "p4=10.0.0.0/8", "p4>=10.0.0.0/8",      "p4=10.0.0.0/8" },
                { ">= ipv4 prefix, contains",   "p4=10.0.0.0/8", "p4>=0.0.0.0/0",       "p4=0.0.0.0/0" },
                { ">= ipv4 prefix, disjoint",   "p4=10.0.0.0/8", "p4>=192.168.0.0/16",  "p4=192.168.0.0/16" },
 
                /*
                 *      IPv6.
                 */
                { "<= ipv6 prefix, inside",     "p6=2001:db8::/32", "p6<=2001:db8:1::/48",      "p6=2001:db8::/32" },
                { "<= ipv6 prefix, equal",      "p6=2001:db8::/32", "p6<=2001:db8::/32",        "p6=2001:db8::/32" },
                { "<= ipv6 prefix, contains",   "p6=2001:db8::/32", "p6<=::/0",                 "p6=2001:db8::/32" },
                { "<= ipv6 prefix, disjoint",   "p6=2001:db8::/32", "p6<=fe80::/10",            "p6=2001:db8::/32" },
                { ">= ipv6 prefix, inside",     "p6=2001:db8::/32", "p6>=2001:db8:1::/48",      "p6=2001:db8:1::/48" },
                { ">= ipv6 prefix, equal",      "p6=2001:db8::/32", "p6>=2001:db8::/32",        "p6=2001:db8::/32" },
                { ">= ipv6 prefix, contains",   "p6=2001:db8::/32", "p6>=::/0",                 "p6=::/0" },
                { ">= ipv6 prefix, disjoint",   "p6=2001:db8::/32", "p6>=fe80::/10",            "p6=fe80::/10" },
 
                /*
                 *      No existing prefix, so the pair is added.
                 */
                { "<= prefix, absent",          "",             "p4<=10.0.0.0/8",       "p4=10.0.0.0/8" },
                { ">= prefix, absent",          "",             "p6>=2001:db8::/32",    "p6=2001:db8::/32" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The operators apply to the original `to` list only.  The operators do
 *      not apply to attributes that the same `radius_pairmove()` call adds.
 */
static void test_original_list_only(void)
{
        static pairmove_case_t const cases[] = {
                { "+= then :=",                 "s0=a",         "s0+=x s0:=y",  "s0=y s0=x" },
                { "+= then -=",                 "s0=a",         "s0+=a s0-=a",  "s0=a" },
                { "+= then !*",                 "s0=a",         "s0+=b s0!*",   "s0=b" },
                { ":= then -=",                 "s0=a",         "s0:=b s0-=b",  "s0=b" },
                { "^= then !*",                 "s0=a",         "s0^=b s0!*",   "s0=b" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      The '=' operator looks for an instance of the attribute in the `to`
 *      list as the earlier pairs of the `from` list have left it.  An
 *      instance which an earlier pair replaced, or deleted, does not count.
 *      An instance which no earlier pair touched does count.
 */
static void test_op_eq_after_edit(void)
{
        static pairmove_case_t const cases[] = {
                { ":= then =",                  "s0=a",         "s0:=b s0=c",   "s0=b s0=c" },
                { "-= then =",                  "s0=a",         "s0-=a s0=b",   "s0=b" },
                { "!* then =",                  "s0=a s0=x",    "s0!* s0=b",    "s0=b" },
                { "<= then =",                  "i0=10",        "i0<=5 i0=7",   "i0=5 i0=7" },
                { ">= then =",                  "i0=1",         "i0>=5 i0=7",   "i0=5 i0=7" },
 
                /*
                 *      The second instance was not touched, so '=' finds it.
                 */
                { ":= then =, two instances",   "s0=a s0=x",    "s0:=b s0=c",   "s0=b s0=x" },
                { "-= then =, two instances",   "s0=a s0=x",    "s0-=a s0=c",   "s0=x" },
 
                /*
                 *      An edit of another attribute has no effect.
                 */
                { "other attribute then =",     "s0=a s1=x",    "s1:=y s0=c",   "s0=a s1=y" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      A pair which `radius_pairmove()` moves out of the `from` list must leave
 *      the `from` list completely.  In each case below, a pair which stays in the
 *      result is followed in the `from` list by a pair which is freed, replaces
 *      an existing pair, or goes to the start of the list.  If the first pair
 *      stays linked to the second one, then the result has extra entries at the
 *      end, or the result contains a pair which has been freed.
 */
static void test_stale_next(void)
{
        static pairmove_case_t const cases[] = {
                /*
                 *      The pair which follows is freed.
                 */
                { "+= then -=",                 "s0=a",         "s1+=x s0-=a",  "s1=x" },
                { "+= then !*",                 "s0=a s1=b",    "i0+=1 s0!*",   "s1=b i0=1" },
                { "+= then == (no match)",      "s0=a",         "s1+=x s0==b",  "s1=x" },
                { "+= then = (present)",        "s0=a",         "s1+=x s0=b",   "s0=a s1=x" },
                { "+= then <= (kept)",          "i0=3",         "s1+=x i0<=5",  "i0=3 s1=x" },
                { "+= then >= (kept)",          "i0=9",         "s1+=x i0>=5",  "i0=9 s1=x" },
                { "+= then two freed",          "s0=a s2=c",    "s1+=x s0-=a s2!*", "s1=x" },
                { "two += then freed",          "s0=a",         "s1+=x s2+=y s0-=a", "s1=x s2=y" },
 
                /*
                 *      The pair which follows replaces an existing pair.
                 */
                { "+= then :=",                 "s0=a",         "s1+=x s0:=y",  "s0=y s1=x" },
                { "+= then <= (replaced)",      "i0=10",        "s1+=x i0<=5",  "i0=5 s1=x" },
                { "+= then >= (replaced)",      "i0=1",         "s1+=x i0>=5",  "i0=5 s1=x" },
 
                /*
                 *      The pair which follows goes to the start of the list.
                 */
                { "+= then ^=",                 "s0=a",         "s1+=x s2^=y",  "s2=y s0=a s1=x" },
                { "^= then -=",                 "s0=a s2=z",    "s1^=x s0-=a",  "s1=x s2=z" },
 
                /*
                 *      The replacing pair is followed by a pair which is freed.
                 */
                { ":= then -=",                 "s0=a s2=z",    "s0:=b s1-=q",  "s0=b s2=z" },
                { ":= then !*",                 "s0=a s2=z",    "s0:=b s2!*",   "s0=b" },
 
                /*
                 *      A pair which is added is followed by one which is added.
                 */
                { "= then +=",                  "",             "s0=a s1+=b",   "s0=a s1=b" },
                { ":= (absent) then -=",        "",             "s0:=a s1-=b",  "s0=a" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/*
 *      These cases use several operators and several attributes in one call
 *      to `radius_pairmove()`.
 */
static void test_mixed(void)
{
        static pairmove_case_t const cases[] = {
                { "all operators",
                  "s0=a s1=b s2=c i0=1 i1=2",
                  "s0:=A s1-=b s2!* i0<=0 i1+=3 un=bob",
                  "s0=A i0=0 i1=2 i1=3 un=bob" },
                { "different attributes",
                  "s0=a i0=1",
                  "s1=b i1=2 s2=c",
                  "s0=a i0=1 s1=b i1=2 s2=c" },
                { "prepend, replace, append",
                  "s0=a s1=b",
                  "i0^=1 s1:=B i1+=2",
                  "i0=1 s0=a s1=B i1=2" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
/** Merge lists of up to 100 pairs
 *
 * This test checks the sizes of the temporary arrays that
 * `radius_pairmove()` allocates.  The lengths of the `to` list and the
 * `from` list are 1 and 100, 100 and 1, 100 and 100, 0 and 100, and 100
 * and 0.
 */
static void test_long_lists(void)
{
        static struct {
                size_t  to_num;
                size_t  from_num;
        } const sizes[] = { { 1, 100 }, { 100, 1 }, { 100, 100 }, { 0, 100 }, { 100, 0 } };
 
        size_t          i, j;
        list_target_t   target;
 
        for (i = 0; i < NUM_ELEMENTS(sizes); i++) {
                for (target = LIST_REQUEST; target < LIST_NUM; target++) {
                        request_t       *request;
                        TALLOC_CTX      *ctx;
                        fr_pair_list_t  *to;
                        fr_pair_list_t  from;
                        fr_pair_t       *vp;
                        size_t          before;
 
                        request = request_make();
                        to = list_target(&ctx, request, target);
                        before = talloc_total_blocks(request);
 
                        fr_pair_list_init(&from);
 
                        for (j = 0; j < sizes[i].to_num; j++) {
                                TEST_ASSERT(fr_pair_append_by_da(ctx, &vp, to, attr_names[0].da) == 0);
                                TEST_ASSERT(fr_pair_value_from_str(vp, "to", 2, NULL, false) == 0);
                                vp->op = T_OP_EQ;
                        }
 
                        for (j = 0; j < sizes[i].from_num; j++) {
                                TEST_ASSERT(fr_pair_append_by_da(ctx, &vp, &from, attr_names[1].da) == 0);
                                TEST_ASSERT(fr_pair_value_from_str(vp, "from", 4, NULL, false) == 0);
                                vp->op = T_OP_ADD_EQ;
                        }
 
                        radius_pairmove(request, to, &from);
 
                        TEST_CASE_("long lists %zu and %zu: %s", sizes[i].to_num, sizes[i].from_num,
                                   list_target_names[target]);
                        TEST_CHECK(fr_pair_list_num_elements(to) == (sizes[i].to_num + sizes[i].from_num));
                        TEST_MSG("Expected length : %zu", sizes[i].to_num + sizes[i].from_num);
                        TEST_MSG("Got length      : %zu", fr_pair_list_num_elements(to));
 
                        /*
                         *      The `to` attributes come first, then the `from` attributes.
                         */
                        j = 0;
                        fr_pair_list_foreach(to, pair) {
                                TEST_CHECK(pair->da == ((j < sizes[i].to_num) ? attr_names[0].da : attr_names[1].da));
                                j++;
                        }
 
                        fr_pair_list_free(to);
                        TEST_CHECK(talloc_total_blocks(request) == before);
 
                        talloc_free(request);
                }
        }
}
 
/*
 *      The `to` list is empty.  The operators which add a pair add it to the
 *      empty list.  The operators which look for an instance of the attribute
 *      find nothing, and then delete nothing.
 */
static void test_empty_to(void)
{
        static pairmove_case_t const cases[] = {
                /*
                 *      One operator.
                 */
                { "= (empty to)",               "",             "s0=a",         "s0=a" },
                { ":= (empty to)",              "",             "s0:=a",        "s0=a" },
                { "+= (empty to)",              "",             "s0+=a",        "s0=a" },
                { "^= (empty to)",              "",             "s0^=a",        "s0=a" },
                { "-= (empty to)",              "",             "s0-=a",        "" },
                { "!* (empty to)",              "",             "s0!*",         "" },
                { "== (empty to)",              "",             "s0==a",        "" },
                { "<= (empty to)",              "",             "i0<=5",        "i0=5" },
                { ">= (empty to)",              "",             "i0>=5",        "i0=5" },
                { "<= prefix (empty to)",       "",             "p4<=10.0.0.0/8", "p4=10.0.0.0/8" },
                { ">= prefix (empty to)",       "",             "p6>=2001:db8::/32", "p6=2001:db8::/32" },
 
                /*
                 *      The same operator twice.  Because the `to` list has no instance of
                 *      the attribute, the merge adds both pairs.
                 */
                { "= twice",                    "",             "s0=a s0=b",    "s0=a s0=b" },
                { ":= twice",                   "",             "s0:=a s0:=b",  "s0=a s0=b" },
                { "+= twice",                   "",             "s0+=a s0+=b",  "s0=a s0=b" },
                { "^= twice",                   "",             "s0^=a s0^=b",  "s0=b s0=a" },
                { "-= twice",                   "",             "s0-=a s0-=b",  "" },
                { "!* twice",                   "",             "s0!* s0!*",    "" },
                { "== twice",                   "",             "s0==a s0==b",  "" },
                { "<= twice",                   "",             "i0<=5 i0<=3",  "i0=5 i0=3" },
                { ">= twice",                   "",             "i0>=5 i0>=7",  "i0=5 i0=7" },
 
                /*
                 *      A later pair does not apply to a pair which an earlier pair added.
                 */
                { "= then :=",                  "",             "s0=a s0:=b",   "s0=a s0=b" },
                { ":= then =",                  "",             "s0:=a s0=b",   "s0=a s0=b" },
                { "+= then -=",                 "",             "s0+=a s0-=a",  "s0=a" },
                { "+= then !*",                 "",             "s0+=a s0!*",   "s0=a" },
                { "+= then ==",                 "",             "s0+=a s0==b",  "s0=a" },
                { "^= then !*",                 "",             "s0^=a s0!*",   "s0=a" },
 
                /*
                 *      Pairs which delete nothing do not change the pairs which are added.
                 */
                { "deletes then add",           "",             "s0-=a s1!* s2==c i0=1", "i0=1" },
                { "add then deletes",           "",             "i0=1 s0-=a s1!* s2==c", "i0=1" },
                { "add between deletes",        "",             "s0-=a i0=1 s1!*", "i0=1" },
 
                /*
                 *      Several attributes, in the order of the `from` list.
                 */
                { "different attributes",       "",             "s0=a i0:=1 s1+=b", "s0=a i0=1 s1=b" },
                { "prepend and append",         "",             "s0=a s1^=b s2+=c", "s1=b s0=a s2=c" },
                { "all operators",
                  "",
                  "s0=a i0:=1 s1+=b s2^=c i1<=4 s0-=x s1!* un=bob",
                  "s2=c s0=a i0=1 s1=b i1=4 un=bob" },
        };
 
        pairmove_run_cases(cases, NUM_ELEMENTS(cases));
}
 
TEST_LIST = {
        { "op_eq",                              test_op_eq },
        { "op_set",                             test_op_set },
        { "op_add",                             test_op_add },
        { "op_prepend",                         test_op_prepend },
        { "op_sub",                             test_op_sub },
        { "op_cmp_false",                       test_op_cmp_false },
        { "op_cmp_eq",                          test_op_cmp_eq },
        { "op_le_ge",                           test_op_le_ge },
        { "op_le_ge_prefix",                    test_op_le_ge_prefix },
        { "original_list_only",                 test_original_list_only },
        { "op_eq_after_edit",                   test_op_eq_after_edit },
        { "stale_next",                         test_stale_next },
        { "mixed",                              test_mixed },
        { "long_lists",                         test_long_lists },
        { "empty_to",                           test_empty_to },
 
        { NULL, NULL }
};