1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include "test_logger.h"
#include <aws/common/byte_buf.h>
#include <stdarg.h>
#include <stdio.h>
/**
* A real logger wouldn't have such size restrictions, but these are good enough for our tests
*/
#define TEST_LOGGER_MAX_LOG_LINE_SIZE 2048
int s_test_logger_log(
struct aws_logger *logger,
enum aws_log_level log_level,
aws_log_subject_t subject,
const char *format,
...) {
(void)subject;
(void)log_level;
va_list format_args;
va_start(format_args, format);
static char buffer[TEST_LOGGER_MAX_LOG_LINE_SIZE];
#ifdef _WIN32
int written = vsnprintf_s(buffer, TEST_LOGGER_MAX_LOG_LINE_SIZE, _TRUNCATE, format, format_args);
#else
int written = vsnprintf(buffer, TEST_LOGGER_MAX_LOG_LINE_SIZE, format, format_args);
#endif /* _WIN32 */
va_end(format_args);
if (written < 0) {
return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
}
struct test_logger_impl *impl = (struct test_logger_impl *)logger->p_impl;
struct aws_byte_cursor line = aws_byte_cursor_from_array(buffer, written);
if (impl->max_size) {
if (aws_byte_buf_write(&impl->log_buffer, line.ptr, line.len)) {
return aws_raise_error(AWS_ERROR_SHORT_BUFFER);
}
} else {
if (aws_byte_buf_append_dynamic(&impl->log_buffer, &line)) {
return aws_raise_error(AWS_ERROR_SHORT_BUFFER);
}
}
return AWS_OP_SUCCESS;
}
enum aws_log_level s_test_logger_get_log_level(struct aws_logger *logger, aws_log_subject_t subject) {
(void)subject;
struct test_logger_impl *impl = (struct test_logger_impl *)logger->p_impl;
return impl->level;
}
void s_test_logger_clean_up(struct aws_logger *logger) {
struct test_logger_impl *impl = (struct test_logger_impl *)logger->p_impl;
aws_byte_buf_clean_up(&impl->log_buffer);
struct aws_allocator *allocator = logger->allocator;
aws_mem_release(allocator, impl);
}
int s_test_logger_set_log_level(struct aws_logger *logger, enum aws_log_level level) {
struct test_logger_impl *impl = (struct test_logger_impl *)logger->p_impl;
impl->level = level;
return AWS_OP_SUCCESS;
}
static struct aws_logger_vtable s_test_logger_vtable = {
.get_log_level = s_test_logger_get_log_level,
.log = s_test_logger_log,
.clean_up = s_test_logger_clean_up,
.set_log_level = s_test_logger_set_log_level,
};
int test_logger_init(
struct aws_logger *logger,
struct aws_allocator *allocator,
enum aws_log_level level,
size_t max_size) {
struct test_logger_impl *impl =
(struct test_logger_impl *)aws_mem_acquire(allocator, sizeof(struct test_logger_impl));
if (impl == NULL) {
return AWS_OP_ERR;
}
if (aws_byte_buf_init(&impl->log_buffer, allocator, max_size ? max_size : 4096)) {
aws_mem_release(allocator, impl);
return AWS_OP_ERR;
}
impl->level = level;
impl->max_size = max_size;
logger->vtable = &s_test_logger_vtable;
logger->allocator = allocator;
logger->p_impl = impl;
return AWS_OP_SUCCESS;
}
int test_logger_get_contents(struct aws_logger *logger, char *buffer, size_t max_length) {
struct test_logger_impl *impl = (struct test_logger_impl *)logger->p_impl;
if (max_length == 0) {
return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
}
size_t copy_length = max_length - 1;
if (impl->log_buffer.len < copy_length) {
copy_length = impl->log_buffer.len;
}
if (copy_length > 0) {
memcpy(buffer, impl->log_buffer.buffer, copy_length);
}
buffer[copy_length] = 0;
return AWS_OP_SUCCESS;
}
|
