diff options
Diffstat (limited to 'lib/audit_logging/tests/audit_logging_test.c')
| -rw-r--r-- | lib/audit_logging/tests/audit_logging_test.c | 919 |
1 files changed, 919 insertions, 0 deletions
diff --git a/lib/audit_logging/tests/audit_logging_test.c b/lib/audit_logging/tests/audit_logging_test.c new file mode 100644 index 0000000..0923882 --- /dev/null +++ b/lib/audit_logging/tests/audit_logging_test.c @@ -0,0 +1,919 @@ +/* + * Unit tests for the audit_logging library. + * + * Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018 + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + */ + +/* + * from cmocka.c: + * These headers or their equivalents should be included prior to + * including + * this header file. + * + * #include <stdarg.h> + * #include <stddef.h> + * #include <setjmp.h> + * + * This allows test applications to use custom definitions of C standard + * library functions and types. + * + */ + +/* + * Note that the messaging routines (audit_message_send and get_event_server) + * are not tested by these unit tests. Currently they are for integration + * test support, and as such are exercised by the integration tests. + */ +#include <stdarg.h> +#include <stddef.h> +#include <setjmp.h> +#include <cmocka.h> + +#include <string.h> +#include <time.h> +#include <tevent.h> +#include <config.h> +#include <talloc.h> +#include "lib/util/talloc_stack.h" + +#include "lib/util/data_blob.h" +#include "lib/util/time.h" +#include "libcli/util/werror.h" +#include "lib/param/loadparm.h" +#include "libcli/security/dom_sid.h" +#include "librpc/ndr/libndr.h" + +#include "lib/audit_logging/audit_logging.h" + +static void test_json_add_int(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + json_int_t m; + double n; + int rc = 0; + intmax_t big_int = ((intmax_t)1)<<33; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + rc = json_add_int(&object, "positive_one", 1); + assert_int_equal(0, rc); + rc = json_add_int(&object, "zero", 0); + assert_int_equal(0, rc); + rc = json_add_int(&object, "negative_one", -1); + assert_int_equal(0, rc); + rc = json_add_int(&object, "big_int", big_int); + assert_int_equal(0, rc); + + assert_int_equal(4, json_object_size(object.root)); + + value = json_object_get(object.root, "positive_one"); + assert_true(json_is_integer(value)); + n = json_number_value(value); + assert_true(n == 1.0); + + value = json_object_get(object.root, "zero"); + assert_true(json_is_integer(value)); + n = json_number_value(value); + assert_true(n == 0.0); + + value = json_object_get(object.root, "negative_one"); + assert_true(json_is_integer(value)); + n = json_number_value(value); + assert_true(n == -1.0); + + value = json_object_get(object.root, "big_int"); + assert_true(json_is_integer(value)); + m = json_integer_value(value); + assert_int_equal(m, big_int); + + object.valid = false; + rc = json_add_int(&object, "should fail 1", 0xf1); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_int(&object, "should fail 2", 0xf2); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_bool(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + int rc = 0; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + rc = json_add_bool(&object, "true", true); + assert_int_equal(0, rc); + rc = json_add_bool(&object, "false", false); + assert_int_equal(0, rc); + + assert_int_equal(2, json_object_size(object.root)); + + value = json_object_get(object.root, "true"); + assert_true(json_is_boolean(value)); + assert_true(value == json_true()); + + value = json_object_get(object.root, "false"); + assert_true(json_is_boolean(value)); + assert_true(value == json_false()); + + object.valid = false; + rc = json_add_bool(&object, "should fail 1", true); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_bool(&object, "should fail 2", false); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_string(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + const char *s = NULL; + int rc = 0; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + rc = json_add_string(&object, "null", NULL); + assert_int_equal(0, rc); + rc = json_add_string(&object, "empty", ""); + assert_int_equal(0, rc); + rc = json_add_string(&object, "name", "value"); + assert_int_equal(0, rc); + + assert_int_equal(3, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "empty"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("", s); + + value = json_object_get(object.root, "name"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("value", s); + + object.valid = false; + rc = json_add_string(&object, "should fail 1", "A value"); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_string(&object, "should fail 2", "Another value"); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_object(_UNUSED_ void **state) +{ + struct json_object object; + struct json_object other; + struct json_object after; + struct json_object invalid = json_empty_object; + struct json_t *value = NULL; + int rc = 0; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + other = json_new_object(); + assert_false(json_is_invalid(&other)); + rc = json_add_object(&object, "null", NULL); + assert_int_equal(0, rc); + rc = json_add_object(&object, "other", &other); + assert_int_equal(0, rc); + + assert_int_equal(2, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "other"); + assert_true(json_is_object(value)); + assert_ptr_equal(other.root, value); + + rc = json_add_object(&object, "invalid", &invalid); + assert_int_equal(JSON_ERROR, rc); + + object.valid = false; + after = json_new_object(); + assert_false(json_is_invalid(&after)); + rc = json_add_object(&object, "after", &after); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_object(&object, "after", &after); + assert_int_equal(JSON_ERROR, rc); + + json_free(&after); +} + +static void test_json_add_to_array(_UNUSED_ void **state) +{ + struct json_object array; + struct json_object o1; + struct json_object o2; + struct json_object o3; + struct json_object after; + struct json_object invalid = json_empty_object; + struct json_t *value = NULL; + int rc = 0; + + array = json_new_array(); + assert_false(json_is_invalid(&array)); + assert_true(json_is_array(array.root)); + + o1 = json_new_object(); + assert_false(json_is_invalid(&o1)); + o2 = json_new_object(); + assert_false(json_is_invalid(&o2)); + o3 = json_new_object(); + assert_false(json_is_invalid(&o3)); + + rc = json_add_object(&array, NULL, &o3); + assert_int_equal(0, rc); + rc = json_add_object(&array, "", &o2); + assert_int_equal(0, rc); + rc = json_add_object(&array, "will-be-ignored", &o1); + assert_int_equal(0, rc); + rc = json_add_object(&array, NULL, NULL); + assert_int_equal(0, rc); + + assert_int_equal(4, json_array_size(array.root)); + + value = json_array_get(array.root, 0); + assert_ptr_equal(o3.root, value); + + value = json_array_get(array.root, 1); + assert_ptr_equal(o2.root, value); + + value = json_array_get(array.root, 2); + assert_ptr_equal(o1.root, value); + + value = json_array_get(array.root, 3); + assert_true(json_is_null(value)); + + rc = json_add_object(&array, "invalid", &invalid); + assert_int_equal(JSON_ERROR, rc); + + array.valid = false; + after = json_new_object(); + assert_false(json_is_invalid(&after)); + rc = json_add_object(&array, "after", &after); + assert_int_equal(JSON_ERROR, rc); + + json_free(&array); + + rc = json_add_object(&array, "after", &after); + assert_int_equal(JSON_ERROR, rc); + + json_free(&after); +} + +static void test_json_add_timestamp(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *ts = NULL; + const char *t = NULL; + int rc; + int usec, tz; + char c[2]; + struct tm tm; + time_t before; + time_t after; + time_t actual; + struct timeval tv; + int ret; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + ret = gettimeofday(&tv, NULL); + assert_int_equal(0, ret); + before = tv.tv_sec; + + rc = json_add_timestamp(&object); + assert_int_equal(0, rc); + + ret = gettimeofday(&tv, NULL); + assert_int_equal(0, ret); + after = tv.tv_sec; + + ts = json_object_get(object.root, "timestamp"); + assert_true(json_is_string(ts)); + + /* + * Convert the returned ISO 8601 timestamp into a time_t + * Note for convenience we ignore the value of the microsecond + * part of the time stamp. + */ + t = json_string_value(ts); + rc = sscanf( + t, + "%4d-%2d-%2dT%2d:%2d:%2d.%6d%1c%4d", + &tm.tm_year, + &tm.tm_mon, + &tm.tm_mday, + &tm.tm_hour, + &tm.tm_min, + &tm.tm_sec, + &usec, + c, + &tz); + assert_int_equal(9, rc); + tm.tm_year = tm.tm_year - 1900; + tm.tm_mon = tm.tm_mon - 1; + tm.tm_isdst = -1; + actual = mktime(&tm); + + /* + * The timestamp should be before <= actual <= after + */ + assert_true(difftime(actual, before) >= 0); + assert_true(difftime(after, actual) >= 0); + + object.valid = false; + rc = json_add_timestamp(&object); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_timestamp(&object); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_stringn(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + const char *s = NULL; + int rc = 0; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + rc = json_add_stringn(&object, "null", NULL, 10); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "null-zero-len", NULL, 0); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "empty", "", 1); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "empty-zero-len", "", 0); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "value-less-than-len", "123456", 7); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "value-greater-than-len", "abcd", 3); + assert_int_equal(0, rc); + rc = json_add_stringn(&object, "value-equal-len", "ZYX", 3); + assert_int_equal(0, rc); + rc = json_add_stringn( + &object, "value-len-is-zero", "this will be null", 0); + assert_int_equal(0, rc); + + assert_int_equal(8, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "null-zero-len"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "empty"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("", s); + + value = json_object_get(object.root, "empty-zero-len"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "value-greater-than-len"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("abc", s); + assert_int_equal(3, strlen(s)); + + value = json_object_get(object.root, "value-equal-len"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("ZYX", s); + assert_int_equal(3, strlen(s)); + + value = json_object_get(object.root, "value-len-is-zero"); + assert_true(json_is_null(value)); + + object.valid = false; + rc = json_add_stringn(&object, "fail-01", "xxxxxxx", 1); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_stringn(&object, "fail-02", "xxxxxxx", 1); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_version(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *version = NULL; + struct json_t *v = NULL; + double n; + int rc; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + rc = json_add_version(&object, 3, 1); + assert_int_equal(0, rc); + + assert_int_equal(1, json_object_size(object.root)); + + version = json_object_get(object.root, "version"); + assert_true(json_is_object(version)); + assert_int_equal(2, json_object_size(version)); + + v = json_object_get(version, "major"); + assert_true(json_is_integer(v)); + n = json_number_value(v); + assert_true(n == 3.0); + + v = json_object_get(version, "minor"); + assert_true(json_is_integer(v)); + n = json_number_value(v); + assert_true(n == 1.0); + + object.valid = false; + rc = json_add_version(&object, 3, 1); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_version(&object, 3, 1); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_address(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + struct tsocket_address *ip4 = NULL; + struct tsocket_address *ip6 = NULL; + struct tsocket_address *pipe = NULL; + + struct tsocket_address *after = NULL; + const char *s = NULL; + int rc; + + TALLOC_CTX *ctx = talloc_new(NULL); + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + rc = json_add_address(&object, "null", NULL); + assert_int_equal(0, rc); + + rc = tsocket_address_inet_from_strings( + ctx, + "ip", + "127.0.0.1", + 21, + &ip4); + assert_int_equal(0, rc); + rc = json_add_address(&object, "ip4", ip4); + assert_int_equal(0, rc); + + rc = tsocket_address_inet_from_strings( + ctx, + "ip", + "2001:db8:0:0:1:0:0:1", + 42, + &ip6); + assert_int_equal(0, rc); + rc = json_add_address(&object, "ip6", ip6); + assert_int_equal(0, rc); + + rc = tsocket_address_unix_from_path(ctx, "/samba/pipe", &pipe); + assert_int_equal(0, rc); + rc = json_add_address(&object, "pipe", pipe); + assert_int_equal(0, rc); + + assert_int_equal(4, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "ip4"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("ipv4:127.0.0.1:21", s); + + value = json_object_get(object.root, "ip6"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("ipv6:2001:db8::1:0:0:1:42", s); + + value = json_object_get(object.root, "pipe"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal("unix:/samba/pipe", s); + + object.valid = false; + rc = tsocket_address_inet_from_strings( + ctx, "ip", "127.0.0.11", 23, &after); + assert_int_equal(0, rc); + rc = json_add_address(&object, "invalid_object", after); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_address(&object, "freed object", after); + assert_int_equal(JSON_ERROR, rc); + + TALLOC_FREE(ctx); +} + +static void test_json_add_sid(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + const char *SID = "S-1-5-21-2470180966-3899876309-2637894779"; + struct dom_sid sid; + const char *s = NULL; + int rc; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + rc = json_add_sid(&object, "null", NULL); + assert_int_equal(0, rc); + + assert_true(string_to_sid(&sid, SID)); + rc = json_add_sid(&object, "sid", &sid); + assert_int_equal(0, rc); + + assert_int_equal(2, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "sid"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal(SID, s); + + object.valid = false; + rc = json_add_sid(&object, "invalid_object", &sid); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_sid(&object, "freed_object", &sid); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_add_guid(_UNUSED_ void **state) +{ + struct json_object object; + struct json_t *value = NULL; + const char *GUID = "3ab88633-1e57-4c1a-856c-d1bc4b15bbb1"; + struct GUID guid; + const char *s = NULL; + NTSTATUS status; + int rc; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + rc = json_add_guid(&object, "null", NULL); + assert_int_equal(0, rc); + + status = GUID_from_string(GUID, &guid); + assert_true(NT_STATUS_IS_OK(status)); + rc = json_add_guid(&object, "guid", &guid); + assert_int_equal(0, rc); + + assert_int_equal(2, json_object_size(object.root)); + + value = json_object_get(object.root, "null"); + assert_true(json_is_null(value)); + + value = json_object_get(object.root, "guid"); + assert_true(json_is_string(value)); + s = json_string_value(value); + assert_string_equal(GUID, s); + + object.valid = false; + rc = json_add_guid(&object, "invalid_object", &guid); + assert_int_equal(JSON_ERROR, rc); + + json_free(&object); + + rc = json_add_guid(&object, "freed_object", &guid); + assert_int_equal(JSON_ERROR, rc); +} + +static void test_json_to_string(_UNUSED_ void **state) +{ + struct json_object object; + char *s = NULL; + int rc; + + TALLOC_CTX *ctx = talloc_new(NULL); + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + s = json_to_string(ctx, &object); + assert_string_equal("{}", s); + TALLOC_FREE(s); + + rc = json_add_string(&object, "name", "value"); + assert_int_equal(0, rc); + s = json_to_string(ctx, &object); + assert_string_equal("{\"name\": \"value\"}", s); + TALLOC_FREE(s); + + object.valid = false; + s = json_to_string(ctx, &object); + assert_null(s); + + json_free(&object); + + object.valid = true; + object.root = NULL; + + s = json_to_string(ctx, &object); + assert_null(s); + TALLOC_FREE(ctx); +} + +static void test_json_get_array(_UNUSED_ void **state) +{ + struct json_object object; + struct json_object array; + struct json_object stored_array = json_new_array(); + json_t *value = NULL; + json_t *o = NULL; + struct json_object o1; + struct json_object o2; + int rc; + + assert_false(json_is_invalid(&stored_array)); + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + array = json_get_array(&object, "not-there"); + assert_true(array.valid); + assert_non_null(array.root); + assert_true(json_is_array(array.root)); + json_free(&array); + + o1 = json_new_object(); + assert_false(json_is_invalid(&o1)); + rc = json_add_string(&o1, "value", "value-one"); + assert_int_equal(0, rc); + rc = json_add_object(&stored_array, NULL, &o1); + assert_int_equal(0, rc); + rc = json_add_object(&object, "stored_array", &stored_array); + assert_int_equal(0, rc); + + array = json_get_array(&object, "stored_array"); + assert_true(array.valid); + assert_non_null(array.root); + assert_true(json_is_array(array.root)); + + assert_int_equal(1, json_array_size(array.root)); + + o = json_array_get(array.root, 0); + assert_non_null(o); + assert_true(json_is_object(o)); + + value = json_object_get(o, "value"); + assert_non_null(value); + assert_true(json_is_string(value)); + + assert_string_equal("value-one", json_string_value(value)); + json_free(&array); + + /* + * Now update the array and add it back to the object + */ + array = json_get_array(&object, "stored_array"); + assert_true(json_is_array(array.root)); + o2 = json_new_object(); + assert_false(json_is_invalid(&o2)); + rc = json_add_string(&o2, "value", "value-two"); + assert_int_equal(0, rc); + assert_true(o2.valid); + rc = json_add_object(&array, NULL, &o2); + assert_int_equal(0, rc); + assert_true(json_is_array(array.root)); + rc = json_add_object(&object, "stored_array", &array); + assert_int_equal(0, rc); + assert_true(json_is_array(array.root)); + + array = json_get_array(&object, "stored_array"); + assert_non_null(array.root); + assert_true(json_is_array(array.root)); + assert_true(array.valid); + assert_true(json_is_array(array.root)); + + assert_int_equal(2, json_array_size(array.root)); + + o = json_array_get(array.root, 0); + assert_non_null(o); + assert_true(json_is_object(o)); + + assert_non_null(value); + assert_true(json_is_string(value)); + + assert_string_equal("value-one", json_string_value(value)); + + o = json_array_get(array.root, 1); + assert_non_null(o); + assert_true(json_is_object(o)); + + value = json_object_get(o, "value"); + assert_non_null(value); + assert_true(json_is_string(value)); + + assert_string_equal("value-two", json_string_value(value)); + + json_free(&array); + json_free(&object); + + array = json_get_array(&object, "stored_array"); + assert_false(array.valid); + json_free(&array); +} + +static void test_json_get_object(_UNUSED_ void **state) +{ + struct json_object object; + struct json_object o1; + struct json_object o2; + struct json_object o3; + json_t *value = NULL; + int rc; + + object = json_new_object(); + assert_false(json_is_invalid(&object)); + + o1 = json_get_object(&object, "not-there"); + assert_true(o1.valid); + assert_non_null(o1.root); + assert_true(json_is_object(o1.root)); + json_free(&o1); + + o1 = json_new_object(); + assert_false(json_is_invalid(&o1)); + rc = json_add_string(&o1, "value", "value-one"); + assert_int_equal(0, rc); + rc = json_add_object(&object, "stored_object", &o1); + assert_int_equal(0, rc); + + o2 = json_get_object(&object, "stored_object"); + assert_true(o2.valid); + assert_non_null(o2.root); + assert_true(json_is_object(o2.root)); + + value = json_object_get(o2.root, "value"); + assert_non_null(value); + assert_true(json_is_string(value)); + + assert_string_equal("value-one", json_string_value(value)); + + rc = json_add_string(&o2, "value", "value-two"); + assert_int_equal(0, rc); + rc = json_add_object(&object, "stored_object", &o2); + assert_int_equal(0, rc); + + o3 = json_get_object(&object, "stored_object"); + assert_true(o3.valid); + assert_non_null(o3.root); + assert_true(json_is_object(o3.root)); + + value = json_object_get(o3.root, "value"); + assert_non_null(value); + assert_true(json_is_string(value)); + + assert_string_equal("value-two", json_string_value(value)); + + json_free(&o3); + json_free(&object); + + o3 = json_get_object(&object, "stored_object"); + assert_false(o3.valid); + json_free(&o3); +} + +static void test_audit_get_timestamp(_UNUSED_ void **state) +{ + const char *t = NULL; + char *c; + struct tm tm = {}; + time_t before; + time_t after; + time_t actual; + struct timeval tv; + int ret; + char *env_tz = NULL; + char *orig_tz = NULL; + + TALLOC_CTX *ctx = talloc_new(NULL); + + /* + * Explicitly set the time zone to UTC to make the test easier + */ + env_tz = getenv("TZ"); + if (env_tz != NULL) { + orig_tz = talloc_strdup(ctx, env_tz); + } + setenv("TZ", "UTC", 1); + + ret = gettimeofday(&tv, NULL); + assert_int_equal(0, ret); + before = tv.tv_sec; + + t = audit_get_timestamp(ctx); + + ret = gettimeofday(&tv, NULL); + assert_int_equal(0, ret); + after = tv.tv_sec; + + c = strptime(t, "%a, %d %b %Y %H:%M:%S", &tm); + + /* + * Restore the time zone if we changed it + */ + if (orig_tz != NULL) { + setenv("TZ", orig_tz, 1); + TALLOC_FREE(orig_tz); + } + + assert_non_null(c); + tm.tm_isdst = -1; + if (c != NULL && *c == '.') { + char *e; + strtod(c, &e); + c = e; + } + if (c != NULL && *c == ' ') { + assert_string_equal(" UTC", c); + c += 4; + } + assert_int_equal(0, strlen(c)); + + actual = mktime(&tm); + + /* + * The timestamp should be before <= actual <= after + */ + assert_true(difftime(actual, before) >= 0); + assert_true(difftime(after, actual) >= 0); + + TALLOC_FREE(ctx); +} + +int main(_UNUSED_ int argc, _UNUSED_ const char **argv) +{ + const struct CMUnitTest tests[] = { + cmocka_unit_test(test_json_add_int), + cmocka_unit_test(test_json_add_bool), + cmocka_unit_test(test_json_add_string), + cmocka_unit_test(test_json_add_object), + cmocka_unit_test(test_json_add_to_array), + cmocka_unit_test(test_json_add_timestamp), + cmocka_unit_test(test_json_add_stringn), + cmocka_unit_test(test_json_add_version), + cmocka_unit_test(test_json_add_address), + cmocka_unit_test(test_json_add_sid), + cmocka_unit_test(test_json_add_guid), + cmocka_unit_test(test_json_to_string), + cmocka_unit_test(test_json_get_array), + cmocka_unit_test(test_json_get_object), + cmocka_unit_test(test_audit_get_timestamp), + }; + + cmocka_set_message_output(CM_OUTPUT_SUBUNIT); + return cmocka_run_group_tests(tests, NULL, NULL); +} |