Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Assertion and expectation serialization API.
4 *
5 * Copyright (C) 2019, Google LLC.
6 * Author: Brendan Higgins <brendanhiggins@google.com>
7 */
8#include <kunit/assert.h>
9#include <kunit/test.h>
10
11#include "string-stream.h"
12
13void kunit_base_assert_format(const struct kunit_assert *assert,
14 struct string_stream *stream)
15{
16 const char *expect_or_assert = NULL;
17
18 switch (assert->type) {
19 case KUNIT_EXPECTATION:
20 expect_or_assert = "EXPECTATION";
21 break;
22 case KUNIT_ASSERTION:
23 expect_or_assert = "ASSERTION";
24 break;
25 }
26
27 string_stream_add(stream, "%s FAILED at %s:%d\n",
28 expect_or_assert, assert->file, assert->line);
29}
30EXPORT_SYMBOL_GPL(kunit_base_assert_format);
31
32void kunit_assert_print_msg(const struct kunit_assert *assert,
33 struct string_stream *stream)
34{
35 if (assert->message.fmt)
36 string_stream_add(stream, "\n%pV", &assert->message);
37}
38EXPORT_SYMBOL_GPL(kunit_assert_print_msg);
39
40void kunit_fail_assert_format(const struct kunit_assert *assert,
41 struct string_stream *stream)
42{
43 kunit_base_assert_format(assert, stream);
44 string_stream_add(stream, "%pV", &assert->message);
45}
46EXPORT_SYMBOL_GPL(kunit_fail_assert_format);
47
48void kunit_unary_assert_format(const struct kunit_assert *assert,
49 struct string_stream *stream)
50{
51 struct kunit_unary_assert *unary_assert = container_of(
52 assert, struct kunit_unary_assert, assert);
53
54 kunit_base_assert_format(assert, stream);
55 if (unary_assert->expected_true)
56 string_stream_add(stream,
57 KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n",
58 unary_assert->condition);
59 else
60 string_stream_add(stream,
61 KUNIT_SUBTEST_INDENT "Expected %s to be false, but is true\n",
62 unary_assert->condition);
63 kunit_assert_print_msg(assert, stream);
64}
65EXPORT_SYMBOL_GPL(kunit_unary_assert_format);
66
67void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
68 struct string_stream *stream)
69{
70 struct kunit_ptr_not_err_assert *ptr_assert = container_of(
71 assert, struct kunit_ptr_not_err_assert, assert);
72
73 kunit_base_assert_format(assert, stream);
74 if (!ptr_assert->value) {
75 string_stream_add(stream,
76 KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n",
77 ptr_assert->text);
78 } else if (IS_ERR(ptr_assert->value)) {
79 string_stream_add(stream,
80 KUNIT_SUBTEST_INDENT "Expected %s is not error, but is: %ld\n",
81 ptr_assert->text,
82 PTR_ERR(ptr_assert->value));
83 }
84 kunit_assert_print_msg(assert, stream);
85}
86EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
87
88/* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */
89static bool is_literal(struct kunit *test, const char *text, long long value,
90 gfp_t gfp)
91{
92 char *buffer;
93 int len;
94 bool ret;
95
96 len = snprintf(NULL, 0, "%lld", value);
97 if (strlen(text) != len)
98 return false;
99
100 buffer = kunit_kmalloc(test, len+1, gfp);
101 if (!buffer)
102 return false;
103
104 snprintf(buffer, len+1, "%lld", value);
105 ret = strncmp(buffer, text, len) == 0;
106
107 kunit_kfree(test, buffer);
108 return ret;
109}
110
111void kunit_binary_assert_format(const struct kunit_assert *assert,
112 struct string_stream *stream)
113{
114 struct kunit_binary_assert *binary_assert = container_of(
115 assert, struct kunit_binary_assert, assert);
116
117 kunit_base_assert_format(assert, stream);
118 string_stream_add(stream,
119 KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
120 binary_assert->left_text,
121 binary_assert->operation,
122 binary_assert->right_text);
123 if (!is_literal(stream->test, binary_assert->left_text,
124 binary_assert->left_value, stream->gfp))
125 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",
126 binary_assert->left_text,
127 binary_assert->left_value);
128 if (!is_literal(stream->test, binary_assert->right_text,
129 binary_assert->right_value, stream->gfp))
130 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",
131 binary_assert->right_text,
132 binary_assert->right_value);
133 kunit_assert_print_msg(assert, stream);
134}
135EXPORT_SYMBOL_GPL(kunit_binary_assert_format);
136
137void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
138 struct string_stream *stream)
139{
140 struct kunit_binary_ptr_assert *binary_assert = container_of(
141 assert, struct kunit_binary_ptr_assert, assert);
142
143 kunit_base_assert_format(assert, stream);
144 string_stream_add(stream,
145 KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
146 binary_assert->left_text,
147 binary_assert->operation,
148 binary_assert->right_text);
149 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",
150 binary_assert->left_text,
151 binary_assert->left_value);
152 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",
153 binary_assert->right_text,
154 binary_assert->right_value);
155 kunit_assert_print_msg(assert, stream);
156}
157EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
158
159void kunit_binary_str_assert_format(const struct kunit_assert *assert,
160 struct string_stream *stream)
161{
162 struct kunit_binary_str_assert *binary_assert = container_of(
163 assert, struct kunit_binary_str_assert, assert);
164
165 kunit_base_assert_format(assert, stream);
166 string_stream_add(stream,
167 KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
168 binary_assert->left_text,
169 binary_assert->operation,
170 binary_assert->right_text);
171 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %s\n",
172 binary_assert->left_text,
173 binary_assert->left_value);
174 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %s",
175 binary_assert->right_text,
176 binary_assert->right_value);
177 kunit_assert_print_msg(assert, stream);
178}
179EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);