mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 10:10:06 +00:00
Code Issues Releases Wiki Activity
bind/lib/isc/tests/quota_test.c

340 lines
8.5 KiB
C
Raw Normal View History

Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
Update the copyright information in all files in the repository This commit converts the license handling to adhere to the REUSE specification. It specifically: 1. Adds used licnses to LICENSES/ directory 2. Add "isc" template for adding the copyright boilerplate 3. Changes all source files to include copyright and SPDX license header, this includes all the C sources, documentation, zone files, configuration files. There are notes in the doc/dev/copyrights file on how to add correct headers to the new files. 4. Handle the rest that can't be modified via .reuse/dep5 file. The binary (or otherwise unmodifiable) files could have license places next to them in <foo>.license file, but this would lead to cluttered repository and most of the files handled in the .reuse/dep5 file are system test files.
2021-06-03 08:37:05 +02:00
* SPDX-License-Identifier: MPL-2.0
*
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
update all copyright headers to eliminate the typo
2020-09-14 16:20:40 -07:00
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
#include <uv.h>
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/quota.h>
#include <isc/result.h>
#include <isc/thread.h>
#include <isc/util.h>
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
#include <isc/test.h>
Add nanosleep and usleep Windows shims This commit adds POSIX nanosleep() and usleep() shim implementation for Windows to help implementors use less #ifdef _WIN32 in the code.
2021-04-27 10:16:01 +02:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_RUN_TEST_IMPL(isc_quota_get_set) {
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
UNUSED(state);
isc_quota_t quota;
isc_quota_t *quota2 = NULL;
isc_quota_init(&quota, 100);
assert_int_equal(isc_quota_getmax(&quota), 100);
assert_int_equal(isc_quota_getsoft(&quota), 0);
isc_quota_max(&quota, 50);
isc_quota_soft(&quota, 30);
assert_int_equal(isc_quota_getmax(&quota), 50);
assert_int_equal(isc_quota_getsoft(&quota), 30);
assert_int_equal(isc_quota_getused(&quota), 0);
isc_quota_attach(&quota, &quota2);
assert_int_equal(isc_quota_getused(&quota), 1);
isc_quota_detach(&quota2);
assert_int_equal(isc_quota_getused(&quota), 0);
isc_quota_destroy(&quota);
}
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
static void
add_quota(isc_quota_t *source, isc_quota_t **target,
isc_result_t expected_result, int expected_used) {
isc_result_t result;
*target = NULL;
result = isc_quota_attach(source, target);
assert_int_equal(result, expected_result);
switch (expected_result) {
case ISC_R_SUCCESS:
case ISC_R_SOFTQUOTA:
assert_ptr_equal(*target, source);
break;
default:
assert_null(*target);
break;
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
assert_int_equal(isc_quota_getused(source), expected_used);
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_RUN_TEST_IMPL(isc_quota_hard) {
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
isc_quota_t quota;
isc_quota_t *quotas[110];
int i;
UNUSED(state);
isc_quota_init(&quota, 100);
for (i = 0; i < 100; i++) {
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[i], ISC_R_SUCCESS, i + 1);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[100], ISC_R_QUOTA, 100);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
assert_int_equal(isc_quota_getused(&quota), 100);
isc_quota_detach(&quotas[0]);
assert_null(quotas[0]);
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[100], ISC_R_SUCCESS, 100);
add_quota(&quota, &quotas[101], ISC_R_QUOTA, 100);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
for (i = 100; i > 0; i--) {
isc_quota_detach(&quotas[i]);
assert_null(quotas[i]);
assert_int_equal(isc_quota_getused(&quota), i - 1);
}
assert_int_equal(isc_quota_getused(&quota), 0);
isc_quota_destroy(&quota);
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_RUN_TEST_IMPL(isc_quota_soft) {
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
isc_quota_t quota;
isc_quota_t *quotas[110];
int i;
UNUSED(state);
isc_quota_init(&quota, 100);
isc_quota_soft(&quota, 50);
for (i = 0; i < 50; i++) {
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[i], ISC_R_SUCCESS, i + 1);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
for (i = 50; i < 100; i++) {
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[i], ISC_R_SOFTQUOTA, i + 1);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
Convert add_quota() to a function cppcheck 2.2 reports the following false positive: lib/isc/tests/quota_test.c:71:21: error: Array 'quotas[101]' accessed at index 110, which is out of bounds. [arrayIndexOutOfBounds] isc_quota_t *quotas[110]; ^ The above is not even an array access, so this report is obviously caused by a cppcheck bug. Yet, it seems to be triggered by the presence of the add_quota() macro, which should really be a function. Convert the add_quota() macro to a function in order to make the code cleaner and to prevent the above cppcheck 2.2 false positive from being triggered.
2020-11-25 12:45:47 +01:00
add_quota(&quota, &quotas[i], ISC_R_QUOTA, 100);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
for (i = 99; i >= 0; i--) {
isc_quota_detach(&quotas[i]);
assert_null(quotas[i]);
assert_int_equal(isc_quota_getused(&quota), i);
}
assert_int_equal(isc_quota_getused(&quota), 0);
isc_quota_destroy(&quota);
}
Remove usage of deprecated ATOMIC_VAR_INIT() macro The C17 standard deprecated ATOMIC_VAR_INIT() macro (see [1]). Follow the suite and remove the ATOMIC_VAR_INIT() usage in favor of simple assignment of the value as this is what all supported stdatomic.h implementations do anyway: * MacOSX.plaform: #define ATOMIC_VAR_INIT(__v) {__v} * Gcc stdatomic.h: #define ATOMIC_VAR_INIT(VALUE) (VALUE) 1. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1138r0.pdf
2022-03-08 23:55:10 +01:00
static atomic_uint_fast32_t cb_calls = 0;
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
static isc_quota_cb_t cbs[30];
static isc_quota_t *qp;
static void
callback(isc_quota_t *quota, void *data) {
int val = *(int *)data;
/* Callback is not called if we get the quota directly */
assert_int_not_equal(val, -1);
/* We get the proper quota pointer */
assert_ptr_equal(quota, qp);
/* Verify that the callbacks are called in order */
int v = atomic_fetch_add_relaxed(&cb_calls, 1);
assert_int_equal(v, val);
/*
* First 5 will be detached by the test function,
* for the last 5 - do a 'chain detach'.
*/
if (v >= 5) {
isc_quota_detach(&quota);
}
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_RUN_TEST_IMPL(isc_quota_callback) {
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
isc_result_t result;
isc_quota_t quota;
isc_quota_t *quotas[30];
qp = &quota;
/*
* - 10 calls that end with SUCCESS
* - 10 calls that end with SOFTQUOTA
* - 10 callbacks
*/
int ints[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int i;
UNUSED(state);
isc_quota_init(&quota, 20);
isc_quota_soft(&quota, 10);
for (i = 0; i < 10; i++) {
quotas[i] = NULL;
isc_quota_cb_init(&cbs[i], callback, &ints[i]);
result = isc_quota_attach_cb(&quota, &quotas[i], &cbs[i]);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(quotas[i], &quota);
assert_int_equal(isc_quota_getused(&quota), i + 1);
}
for (i = 10; i < 20; i++) {
quotas[i] = NULL;
isc_quota_cb_init(&cbs[i], callback, &ints[i]);
result = isc_quota_attach_cb(&quota, &quotas[i], &cbs[i]);
assert_int_equal(result, ISC_R_SOFTQUOTA);
assert_ptr_equal(quotas[i], &quota);
assert_int_equal(isc_quota_getused(&quota), i + 1);
}
for (i = 20; i < 30; i++) {
quotas[i] = NULL;
isc_quota_cb_init(&cbs[i], callback, &ints[i]);
result = isc_quota_attach_cb(&quota, &quotas[i], &cbs[i]);
assert_int_equal(result, ISC_R_QUOTA);
assert_ptr_equal(quotas[i], NULL);
assert_int_equal(isc_quota_getused(&quota), 20);
}
assert_int_equal(atomic_load(&cb_calls), 0);
for (i = 0; i < 5; i++) {
isc_quota_detach(&quotas[i]);
assert_null(quotas[i]);
assert_int_equal(isc_quota_getused(&quota), 20);
assert_int_equal(atomic_load(&cb_calls), i + 1);
}
/* That should cause a chain reaction */
isc_quota_detach(&quotas[5]);
assert_int_equal(atomic_load(&cb_calls), 10);
/* Release the quotas that we did not released in the callback */
for (i = 0; i < 5; i++) {
Fix detaching the extra quotas in the quota_test
2020-04-21 13:33:42 +02:00
qp = &quota;
isc_quota_detach(&qp);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
for (i = 6; i < 20; i++) {
isc_quota_detach(&quotas[i]);
assert_null(quotas[i]);
assert_int_equal(isc_quota_getused(&quota), 19 - i);
}
assert_int_equal(atomic_load(&cb_calls), 10);
assert_int_equal(isc_quota_getused(&quota), 0);
isc_quota_destroy(&quota);
}
/*
* Multithreaded quota callback test:
* - quota set to 100
* - 10 threads, each trying to get 100 quotas.
* - creates a separate thread to release it after 10ms
*/
typedef struct qthreadinfo {
atomic_uint_fast32_t direct;
atomic_uint_fast32_t callback;
isc_quota_t *quota;
isc_quota_cb_t callbacks[100];
} qthreadinfo_t;
Remove usage of deprecated ATOMIC_VAR_INIT() macro The C17 standard deprecated ATOMIC_VAR_INIT() macro (see [1]). Follow the suite and remove the ATOMIC_VAR_INIT() usage in favor of simple assignment of the value as this is what all supported stdatomic.h implementations do anyway: * MacOSX.plaform: #define ATOMIC_VAR_INIT(__v) {__v} * Gcc stdatomic.h: #define ATOMIC_VAR_INIT(VALUE) (VALUE) 1. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1138r0.pdf
2022-03-08 23:55:10 +01:00
static atomic_uint_fast32_t g_tnum = 0;
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
/* at most 10 * 100 quota_detach threads */
isc_thread_t g_threads[10 * 100];
static void *
quota_detach(void *quotap) {
isc_quota_t *quota = (isc_quota_t *)quotap;
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
uv_sleep(10000);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
isc_quota_detach(&quota);
return ((isc_threadresult_t)0);
}
static void
quota_callback(isc_quota_t *quota, void *data) {
qthreadinfo_t *qti = (qthreadinfo_t *)data;
atomic_fetch_add_relaxed(&qti->callback, 1);
int tnum = atomic_fetch_add_relaxed(&g_tnum, 1);
isc_thread_create(quota_detach, quota, &g_threads[tnum]);
}
static isc_threadresult_t
quota_thread(void *qtip) {
qthreadinfo_t *qti = (qthreadinfo_t *)qtip;
for (int i = 0; i < 100; i++) {
isc_quota_cb_init(&qti->callbacks[i], quota_callback, qti);
isc_quota_t *quota = NULL;
isc_result_t result = isc_quota_attach_cb(qti->quota, &quota,
&qti->callbacks[i]);
if (result == ISC_R_SUCCESS) {
atomic_fetch_add_relaxed(&qti->direct, 1);
int tnum = atomic_fetch_add_relaxed(&g_tnum, 1);
isc_thread_create(quota_detach, quota,
&g_threads[tnum]);
}
}
return ((isc_threadresult_t)0);
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_RUN_TEST_IMPL(isc_quota_callback_mt) {
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
UNUSED(state);
isc_quota_t quota;
int i;
isc_quota_init(&quota, 100);
static qthreadinfo_t qtis[10];
isc_thread_t threads[10];
for (i = 0; i < 10; i++) {
atomic_init(&qtis[i].direct, 0);
atomic_init(&qtis[i].callback, 0);
qtis[i].quota = &quota;
isc_thread_create(quota_thread, &qtis[i], &threads[i]);
}
for (i = 0; i < 10; i++) {
isc_thread_join(threads[i], NULL);
}
for (i = 0; i < (int)atomic_load(&g_tnum); i++) {
isc_thread_join(g_threads[i], NULL);
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
int direct = 0, ncallback = 0;
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
for (i = 0; i < 10; i++) {
direct += atomic_load(&qtis[i].direct);
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ncallback += atomic_load(&qtis[i].callback);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
}
/* Total quota gained must be 10 threads * 100 tries */
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
assert_int_equal(direct + ncallback, 10 * 100);
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
/*
* At least 100 must be direct, the rest is virtually random:
* - in a regular run I'm constantly getting 100:900 ratio
* - under rr - usually around ~120:880
* - under rr -h - 1000:0
*/
assert_true(direct >= 100);
isc_quota_destroy(&quota);
}
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_TEST_LIST_START
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_TEST_ENTRY(isc_quota_get_set)
ISC_TEST_ENTRY(isc_quota_hard)
ISC_TEST_ENTRY(isc_quota_soft)
ISC_TEST_ENTRY(isc_quota_callback)
ISC_TEST_ENTRY(isc_quota_callback_mt)
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_TEST_LIST_END
Add a quota attach function with a callback, some code cleanups. We introduce a isc_quota_attach_cb function - if ISC_R_QUOTA is returned at the time the function is called, then a callback will be called when there's quota available (with quota already attached). The callbacks are organized as a LIFO queue in the quota structure. It's needed for TCP client quota - with old networking code we had one single place where tcp clients quota was processed so we could resume accepting when the we had spare slots, but it's gone with netmgr - now we need to notify the listener/accepter that there's quota available so that it can resume accepting. Remove unused isc_quota_force() function. The isc_quote_reserve and isc_quota_release were used only internally from the quota.c and the tests. We should not expose API we are not using.
2020-03-24 11:42:16 +01:00
Give the unit tests a big overhaul The unit tests contain a lot of duplicated code and here's an attempt to reduce code duplication. This commit does several things: 1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake conditionals. 2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test implementations, test lists, and the main test routine, so we don't have to repeat this all over again. The macros were modeled after libuv test suite but adapted to cmocka as the test driver. A simple example of a unit test would be: ISC_RUN_TEST_IMPL(test1) { assert_true(true); } ISC_TEST_LIST_START ISC_TEST_ENTRY(test1) ISC_TEST_LIST_END ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?) For more complicated examples including group setup and teardown functions, and per-test setup and teardown functions. 3. The macros prefix the test functions and cmocka entries, so the name of the test can now match the tested function name, and we don't have to append `_test` because `run_test_` is automatically prepended to the main test function, and `setup_test_` and `teardown_test_` is prepended to setup and teardown function. 4. Update all the unit tests to use the new syntax and fix a few bits here and there. 5. In the future, we can separate the test declarations and test implementations which are going to greatly help with uncluttering the bigger unit tests like doh_test and netmgr_test, because the test implementations are not declared static (see `ISC_RUN_TEST_DECLARE` and `ISC_RUN_TEST_IMPL` for more details. NOTE: This heavily relies on preprocessor macros, but the result greatly outweighs all the negatives of using the macros. There's less duplicated code, the tests are more uniform and the implementation can be more flexible.
2022-05-02 10:56:42 +02:00
ISC_TEST_MAIN
Reference in New Issue Copy Permalink