Merge branch 'fixes-rc1' into fixes
[platform/kernel/linux-rpi.git] / lib / kunit / assert.c
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
13 void 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 }
30 EXPORT_SYMBOL_GPL(kunit_base_assert_format);
31
32 void 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 }
38 EXPORT_SYMBOL_GPL(kunit_assert_print_msg);
39
40 void 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 }
46 EXPORT_SYMBOL_GPL(kunit_fail_assert_format);
47
48 void kunit_unary_assert_format(const struct kunit_assert *assert,
49                                struct string_stream *stream)
50 {
51         struct kunit_unary_assert *unary_assert;
52
53         unary_assert = container_of(assert, struct kunit_unary_assert, assert);
54
55         kunit_base_assert_format(assert, stream);
56         if (unary_assert->expected_true)
57                 string_stream_add(stream,
58                                   KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n",
59                                   unary_assert->condition);
60         else
61                 string_stream_add(stream,
62                                   KUNIT_SUBTEST_INDENT "Expected %s to be false, but is true\n",
63                                   unary_assert->condition);
64         kunit_assert_print_msg(assert, stream);
65 }
66 EXPORT_SYMBOL_GPL(kunit_unary_assert_format);
67
68 void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
69                                      struct string_stream *stream)
70 {
71         struct kunit_ptr_not_err_assert *ptr_assert;
72
73         ptr_assert = container_of(assert, struct kunit_ptr_not_err_assert,
74                                   assert);
75
76         kunit_base_assert_format(assert, stream);
77         if (!ptr_assert->value) {
78                 string_stream_add(stream,
79                                   KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n",
80                                   ptr_assert->text);
81         } else if (IS_ERR(ptr_assert->value)) {
82                 string_stream_add(stream,
83                                   KUNIT_SUBTEST_INDENT "Expected %s is not error, but is: %ld\n",
84                                   ptr_assert->text,
85                                   PTR_ERR(ptr_assert->value));
86         }
87         kunit_assert_print_msg(assert, stream);
88 }
89 EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
90
91 /* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */
92 static bool is_literal(struct kunit *test, const char *text, long long value,
93                        gfp_t gfp)
94 {
95         char *buffer;
96         int len;
97         bool ret;
98
99         len = snprintf(NULL, 0, "%lld", value);
100         if (strlen(text) != len)
101                 return false;
102
103         buffer = kunit_kmalloc(test, len+1, gfp);
104         if (!buffer)
105                 return false;
106
107         snprintf(buffer, len+1, "%lld", value);
108         ret = strncmp(buffer, text, len) == 0;
109
110         kunit_kfree(test, buffer);
111         return ret;
112 }
113
114 void kunit_binary_assert_format(const struct kunit_assert *assert,
115                                 struct string_stream *stream)
116 {
117         struct kunit_binary_assert *binary_assert;
118
119         binary_assert = container_of(assert, struct kunit_binary_assert,
120                                      assert);
121
122         kunit_base_assert_format(assert, stream);
123         string_stream_add(stream,
124                           KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
125                           binary_assert->left_text,
126                           binary_assert->operation,
127                           binary_assert->right_text);
128         if (!is_literal(stream->test, binary_assert->left_text,
129                         binary_assert->left_value, stream->gfp))
130                 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",
131                                   binary_assert->left_text,
132                                   binary_assert->left_value);
133         if (!is_literal(stream->test, binary_assert->right_text,
134                         binary_assert->right_value, stream->gfp))
135                 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",
136                                   binary_assert->right_text,
137                                   binary_assert->right_value);
138         kunit_assert_print_msg(assert, stream);
139 }
140 EXPORT_SYMBOL_GPL(kunit_binary_assert_format);
141
142 void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
143                                     struct string_stream *stream)
144 {
145         struct kunit_binary_ptr_assert *binary_assert;
146
147         binary_assert = container_of(assert, struct kunit_binary_ptr_assert,
148                                      assert);
149
150         kunit_base_assert_format(assert, stream);
151         string_stream_add(stream,
152                           KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
153                           binary_assert->left_text,
154                           binary_assert->operation,
155                           binary_assert->right_text);
156         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",
157                           binary_assert->left_text,
158                           binary_assert->left_value);
159         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",
160                           binary_assert->right_text,
161                           binary_assert->right_value);
162         kunit_assert_print_msg(assert, stream);
163 }
164 EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
165
166 /* Checks if KUNIT_EXPECT_STREQ() args were string literals.
167  * Note: `text` will have ""s where as `value` will not.
168  */
169 static bool is_str_literal(const char *text, const char *value)
170 {
171         int len;
172
173         len = strlen(text);
174         if (len < 2)
175                 return false;
176         if (text[0] != '\"' || text[len - 1] != '\"')
177                 return false;
178
179         return strncmp(text + 1, value, len - 2) == 0;
180 }
181
182 void kunit_binary_str_assert_format(const struct kunit_assert *assert,
183                                     struct string_stream *stream)
184 {
185         struct kunit_binary_str_assert *binary_assert;
186
187         binary_assert = container_of(assert, struct kunit_binary_str_assert,
188                                      assert);
189
190         kunit_base_assert_format(assert, stream);
191         string_stream_add(stream,
192                           KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
193                           binary_assert->left_text,
194                           binary_assert->operation,
195                           binary_assert->right_text);
196         if (!is_str_literal(binary_assert->left_text, binary_assert->left_value))
197                 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"\n",
198                                   binary_assert->left_text,
199                                   binary_assert->left_value);
200         if (!is_str_literal(binary_assert->right_text, binary_assert->right_value))
201                 string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"",
202                                   binary_assert->right_text,
203                                   binary_assert->right_value);
204         kunit_assert_print_msg(assert, stream);
205 }
206 EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);