Home | History | Annotate | Line # | Download | only in dns
diff_test.c revision 1.2 
      1 /*	$NetBSD: diff_test.c,v 1.2 2025/01/26 16:25:47 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
      5  *
      6  * SPDX-License-Identifier: MPL-2.0
      7  *
      8  * This Source Code Form is subject to the terms of the Mozilla Public
      9  * License, v. 2.0. If a copy of the MPL was not distributed with this
     10  * file, you can obtain one at https://mozilla.org/MPL/2.0/.
     11  *
     12  * See the COPYRIGHT file distributed with this work for additional
     13  * information regarding copyright ownership.
     14  */
     15 
     16 /* sched.h must be imported before cmocka to avoid redefinition errors */
     17 #include <sched.h> /* IWYU pragma: keep */
     18 #include <setjmp.h>
     19 #include <stdarg.h>
     20 #include <stddef.h>
     21 #include <stdlib.h>
     22 #include <unistd.h>
     23 
     24 #include "isc/list.h"
     25 
     26 #define UNIT_TESTING
     27 #include <cmocka.h>
     28 
     29 #include <dns/diff.h>
     30 
     31 #include <tests/dns.h>
     32 
     33 unsigned char data_1[] = "\006name_1";
     34 unsigned char offsets_1[] = { 0, 7 };
     35 dns_name_t name_1 = DNS_NAME_INITABSOLUTE(data_1, offsets_1);
     36 
     37 unsigned char data_2[] = "\006name_2";
     38 unsigned char offsets_2[] = { 0, 7 };
     39 dns_name_t name_2 = DNS_NAME_INITABSOLUTE(data_2, offsets_2);
     40 
     41 unsigned char data_3[] = "\006name_3";
     42 unsigned char offsets_3[] = { 0, 7 };
     43 dns_name_t name_3 = DNS_NAME_INITABSOLUTE(data_3, offsets_3);
     44 
     45 unsigned char data_dup[] = "\006name_1";
     46 unsigned char offsets_dup[] = { 0, 7 };
     47 dns_name_t name_dup = DNS_NAME_INITABSOLUTE(data_dup, offsets_dup);
     48 
     49 unsigned char data_nodup[] = "\006name_1";
     50 unsigned char offsets_nodup[] = { 0, 7 };
     51 dns_name_t name_nodup = DNS_NAME_INITABSOLUTE(data_nodup, offsets_nodup);
     52 
     53 static size_t
     54 count_elements(const dns_diff_t *diff) {
     55 	dns_difftuple_t *ot = NULL;
     56 	size_t count = 0;
     57 
     58 	for (ot = ISC_LIST_HEAD(diff->tuples); ot != NULL;
     59 	     ot = ISC_LIST_NEXT(ot, link))
     60 	{
     61 		++count;
     62 	}
     63 
     64 	return count;
     65 }
     66 
     67 static void
     68 prepare_rdata(dns_rdata_t *rdata, unsigned char *dest, size_t dest_size) {
     69 	dns_rdataclass_t rdclass = dns_rdataclass_in;
     70 	dns_rdatatype_t type = dns_rdatatype_wallet;
     71 	const char text[] = "cid-example wid-example";
     72 
     73 	*rdata = (dns_rdata_t)DNS_RDATA_INIT;
     74 	isc_result_t result = dns_test_rdatafromstring(
     75 		rdata, rdclass, type, dest, dest_size, text, false);
     76 	INSIST(result == ISC_R_SUCCESS);
     77 }
     78 
     79 ISC_RUN_TEST_IMPL(dns_diff_size) {
     80 	dns_diff_t diff;
     81 	dns_diff_init(mctx, &diff);
     82 
     83 	assert_true(dns_diff_size(&diff) == 0);
     84 
     85 	dns_rdata_t rdatas[5] = { 0 };
     86 	unsigned char bufs[sizeof(rdatas) / sizeof(*rdatas)][128] = { 0 };
     87 	size_t buf_len = sizeof(bufs[0]);
     88 
     89 	for (size_t idx = 0; idx < sizeof(rdatas) / sizeof(*rdatas); ++idx) {
     90 		prepare_rdata(&rdatas[idx], bufs[idx], buf_len);
     91 	}
     92 
     93 	dns_difftuple_t *tup_1 = NULL, *tup_2 = NULL, *tup_3 = NULL;
     94 	dns_difftuple_create(mctx, DNS_DIFFOP_ADD, &name_1, 1, &rdatas[0],
     95 			     &tup_1);
     96 	dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_2, 1, &rdatas[1],
     97 			     &tup_2);
     98 	dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_3, 1, &rdatas[2],
     99 			     &tup_3);
    100 
    101 	dns_difftuple_t *tup_dup = NULL, *tup_nodup = NULL;
    102 	dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_dup, 1, &rdatas[3],
    103 			     &tup_dup);
    104 	dns_difftuple_create(mctx, DNS_DIFFOP_ADD, &name_nodup, 1, &rdatas[4],
    105 			     &tup_nodup);
    106 
    107 	dns_diff_append(&diff, &tup_1);
    108 	assert_true(dns_diff_size(&diff) == 1);
    109 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    110 
    111 	dns_diff_append(&diff, &tup_2);
    112 	assert_true(dns_diff_size(&diff) == 2);
    113 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    114 
    115 	dns_diff_appendminimal(&diff, &tup_dup);
    116 	assert_true(dns_diff_size(&diff) == 1);
    117 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    118 
    119 	dns_diff_append(&diff, &tup_3);
    120 	assert_true(dns_diff_size(&diff) == 2);
    121 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    122 
    123 	dns_diff_appendminimal(&diff, &tup_nodup);
    124 	assert_true(dns_diff_size(&diff) == 3);
    125 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    126 
    127 	dns_diff_clear(&diff);
    128 	assert_true(dns_diff_size(&diff) == 0);
    129 	assert_true(dns_diff_size(&diff) == count_elements(&diff));
    130 
    131 	dns_difftuple_t *to_clear[] = { tup_1, tup_2, tup_3, tup_dup,
    132 					tup_nodup };
    133 	size_t to_clear_size = sizeof(to_clear) / sizeof(*to_clear);
    134 
    135 	for (size_t idx = 0; idx < to_clear_size; ++idx) {
    136 		if (to_clear[idx] != NULL) {
    137 			dns_difftuple_free(&to_clear[idx]);
    138 		}
    139 	}
    140 }
    141 
    142 ISC_TEST_LIST_START
    143 ISC_TEST_ENTRY(dns_diff_size)
    144 ISC_TEST_LIST_END
    145 
    146 ISC_TEST_MAIN
    147