Home | History | Annotate | Line # | Download | only in dns 
      1 /*	$NetBSD: ede_test.c,v 1.3 2026/01/29 18:37:56 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 #include <inttypes.h>
     17 #include <sched.h> /* IWYU pragma: keep */
     18 #include <setjmp.h>
     19 #include <stdarg.h>
     20 #include <stdbool.h>
     21 #include <stddef.h>
     22 #include <stdio.h>
     23 #include <stdlib.h>
     24 #include <unistd.h>
     25 
     26 #define UNIT_TESTING
     27 #include <cmocka.h>
     28 
     29 #include <isc/list.h>
     30 
     31 #include <dns/ede.h>
     32 
     33 #include "../../lib/dns/ede.c"
     34 
     35 #include <tests/isc.h>
     36 
     37 typedef struct {
     38 	uint16_t code;
     39 	const char *txt;
     40 } ede_test_expected_t;
     41 
     42 static void
     43 dns_ede_test_equals(const ede_test_expected_t *expected, size_t expected_count,
     44 		    dns_edectx_t *edectx) {
     45 	size_t count = 0;
     46 
     47 	for (size_t i = 0; i < DNS_EDE_MAX_ERRORS; i++) {
     48 		dns_ednsopt_t *edns = edectx->ede[i];
     49 
     50 		if (edns == NULL) {
     51 			break;
     52 		}
     53 
     54 		uint16_t code;
     55 		const unsigned char *txt;
     56 
     57 		assert_uint_in_range(count, 0, expected_count);
     58 		assert_int_equal(edns->code, DNS_OPT_EDE);
     59 
     60 		code = ISC_U8TO16_BE(edns->value);
     61 		assert_int_equal(code, expected[count].code);
     62 
     63 		if (edns->length > sizeof(code)) {
     64 			assert_non_null(expected[count].txt);
     65 			txt = edns->value + sizeof(code);
     66 			assert_memory_equal(expected[count].txt, txt,
     67 					    edns->length - sizeof(code));
     68 		} else {
     69 			assert_null(expected[count].txt);
     70 		}
     71 
     72 		count++;
     73 	}
     74 	assert_int_equal(count, expected_count);
     75 }
     76 
     77 ISC_RUN_TEST_IMPL(dns_ede_test_text_max_count) {
     78 	dns_edectx_t edectx;
     79 
     80 	dns_ede_init(mctx, &edectx);
     81 
     82 	const char *txt1 = "foobar";
     83 	const char *txt2 = "It's been a long time since I rock-and-rolled"
     84 			   "Ooh, let me get it back, let me get it back";
     85 
     86 	dns_ede_add(&edectx, 2, txt1);
     87 	dns_ede_add(&edectx, 22, NULL);
     88 	dns_ede_add(&edectx, 3, txt2);
     89 
     90 	const ede_test_expected_t expected[3] = {
     91 		{ .code = 2, .txt = "foobar" },
     92 		{ .code = 22, .txt = NULL },
     93 		{ .code = 3,
     94 		  .txt = "It's been a long time since I rock-and-rolledOoh, "
     95 			 "let me get it " }
     96 	};
     97 
     98 	dns_ede_test_equals(expected, 3, &edectx);
     99 
    100 	dns_ede_reset(&edectx);
    101 }
    102 
    103 ISC_RUN_TEST_IMPL(dns_ede_test_max_count) {
    104 	dns_edectx_t edectx;
    105 
    106 	dns_ede_init(mctx, &edectx);
    107 
    108 	dns_ede_add(&edectx, 1, NULL);
    109 	dns_ede_add(&edectx, 22, "two");
    110 	dns_ede_add(&edectx, 3, "three");
    111 	dns_ede_add(&edectx, 4, "four");
    112 	dns_ede_add(&edectx, 5, "five");
    113 
    114 	const ede_test_expected_t expected[3] = {
    115 		{ .code = 1, .txt = NULL },
    116 		{ .code = 22, .txt = "two" },
    117 		{ .code = 3, .txt = "three" },
    118 	};
    119 
    120 	dns_ede_test_equals(expected, 3, &edectx);
    121 
    122 	dns_ede_reset(&edectx);
    123 }
    124 
    125 ISC_RUN_TEST_IMPL(dns_ede_test_duplicates) {
    126 	dns_edectx_t edectx;
    127 
    128 	dns_ede_init(mctx, &edectx);
    129 
    130 	dns_ede_add(&edectx, 1, NULL);
    131 	dns_ede_add(&edectx, 1, "two");
    132 	dns_ede_add(&edectx, 1, "three");
    133 
    134 	const ede_test_expected_t expected[] = {
    135 		{ .code = 1, .txt = NULL },
    136 	};
    137 	dns_ede_test_equals(expected, 1, &edectx);
    138 
    139 	dns_ede_reset(&edectx);
    140 
    141 	const ede_test_expected_t expectedempty[] = {};
    142 	dns_ede_test_equals(expectedempty, 0, &edectx);
    143 }
    144 
    145 ISC_RUN_TEST_IMPL(dns_ede_test_infocode_range) {
    146 	dns_edectx_t edectx;
    147 
    148 	dns_ede_init(mctx, &edectx);
    149 
    150 	dns_ede_add(&edectx, 1, NULL);
    151 	expect_assert_failure(dns_ede_add(&edectx, 32, NULL));
    152 
    153 	const ede_test_expected_t expected[] = {
    154 		{ .code = 1, .txt = NULL },
    155 	};
    156 	dns_ede_test_equals(expected, 1, &edectx);
    157 
    158 	dns_ede_reset(&edectx);
    159 }
    160 
    161 ISC_RUN_TEST_IMPL(dns_ede_test_copy) {
    162 	dns_edectx_t edectx1;
    163 	dns_edectx_t edectx2;
    164 	dns_edectx_t edectx3;
    165 
    166 	dns_ede_init(mctx, &edectx1);
    167 	dns_ede_init(mctx, &edectx2);
    168 
    169 	dns_ede_add(&edectx1, 1, NULL);
    170 	dns_ede_add(&edectx1, 2, "two-the-first");
    171 	dns_ede_add(&edectx1, 3, "three");
    172 
    173 	const ede_test_expected_t expected[] = {
    174 		{ .code = 1, .txt = NULL },
    175 		{ .code = 2, .txt = "two-the-first" },
    176 		{ .code = 3, .txt = "three" },
    177 	};
    178 
    179 	dns_ede_test_equals(expected, 3, &edectx1);
    180 	dns_ede_copy(&edectx2, &edectx1);
    181 	dns_ede_test_equals(expected, 3, &edectx2);
    182 	dns_ede_test_equals(expected, 3, &edectx1);
    183 
    184 	dns_ede_reset(&edectx2);
    185 	dns_ede_add(&edectx2, 1, "one-the-first-with-txt");
    186 	dns_ede_add(&edectx2, 2, "two-the-second");
    187 
    188 	const ede_test_expected_t expected2[] = {
    189 		{ .code = 1, .txt = "one-the-first-with-txt" },
    190 		{ .code = 2, .txt = "two-the-second" },
    191 		{ .code = 3, .txt = "three" }
    192 	};
    193 
    194 	dns_ede_copy(&edectx2, &edectx1);
    195 	dns_ede_test_equals(expected2, 3, &edectx2);
    196 	dns_ede_test_equals(expected, 3, &edectx1);
    197 
    198 	dns_ede_init(mctx, &edectx3);
    199 	dns_ede_add(&edectx3, 2, "two-the-third");
    200 	dns_ede_copy(&edectx3, &edectx2);
    201 
    202 	const ede_test_expected_t expected3[] = {
    203 		{ .code = 2, .txt = "two-the-third" },
    204 		{ .code = 1, .txt = "one-the-first-with-txt" },
    205 		{ .code = 3, .txt = "three" }
    206 	};
    207 	dns_ede_test_equals(expected3, 3, &edectx3);
    208 
    209 	dns_ede_reset(&edectx1);
    210 	dns_ede_reset(&edectx2);
    211 	dns_ede_reset(&edectx3);
    212 }
    213 
    214 ISC_TEST_LIST_START
    215 
    216 ISC_TEST_ENTRY(dns_ede_test_text_max_count)
    217 ISC_TEST_ENTRY(dns_ede_test_max_count)
    218 ISC_TEST_ENTRY(dns_ede_test_duplicates)
    219 ISC_TEST_ENTRY(dns_ede_test_infocode_range)
    220 ISC_TEST_ENTRY(dns_ede_test_copy)
    221 
    222 ISC_TEST_LIST_END
    223 
    224 ISC_TEST_MAIN
    225