projects/linux·blob v5.6 · refs

151 lines · 4.5 KiB

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 <[email protected]>
7 */
8#include <kunit/assert.h>
9
10#include "string-stream.h"
11
12void kunit_base_assert_format(const struct kunit_assert *assert,
13 struct string_stream *stream)
14{
15 const char *expect_or_assert = NULL;
16
17 switch (assert->type) {
18 case KUNIT_EXPECTATION:
19 expect_or_assert = "EXPECTATION";
20 break;
21 case KUNIT_ASSERTION:
22 expect_or_assert = "ASSERTION";
23 break;
24 }
25
26 string_stream_add(stream, "%s FAILED at %s:%d\n",
27 expect_or_assert, assert->file, assert->line);
28}
29EXPORT_SYMBOL_GPL(kunit_base_assert_format);
30
31void kunit_assert_print_msg(const struct kunit_assert *assert,
32 struct string_stream *stream)
33{
34 if (assert->message.fmt)
35 string_stream_add(stream, "\n%pV", &assert->message);
36}
37EXPORT_SYMBOL_GPL(kunit_assert_print_msg);
38
39void kunit_fail_assert_format(const struct kunit_assert *assert,
40 struct string_stream *stream)
41{
42 kunit_base_assert_format(assert, stream);
43 string_stream_add(stream, "%pV", &assert->message);
44}
45EXPORT_SYMBOL_GPL(kunit_fail_assert_format);
46
47void kunit_unary_assert_format(const struct kunit_assert *assert,
48 struct string_stream *stream)
49{
50 struct kunit_unary_assert *unary_assert = container_of(
51 assert, struct kunit_unary_assert, assert);
52
53 kunit_base_assert_format(assert, stream);
54 if (unary_assert->expected_true)
55 string_stream_add(stream,
56 "\tExpected %s to be true, but is false\n",
57 unary_assert->condition);
58 else
59 string_stream_add(stream,
60 "\tExpected %s to be false, but is true\n",
61 unary_assert->condition);
62 kunit_assert_print_msg(assert, stream);
63}
64EXPORT_SYMBOL_GPL(kunit_unary_assert_format);
65
66void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
67 struct string_stream *stream)
68{
69 struct kunit_ptr_not_err_assert *ptr_assert = container_of(
70 assert, struct kunit_ptr_not_err_assert, assert);
71
72 kunit_base_assert_format(assert, stream);
73 if (!ptr_assert->value) {
74 string_stream_add(stream,
75 "\tExpected %s is not null, but is\n",
76 ptr_assert->text);
77 } else if (IS_ERR(ptr_assert->value)) {
78 string_stream_add(stream,
79 "\tExpected %s is not error, but is: %ld\n",
80 ptr_assert->text,
81 PTR_ERR(ptr_assert->value));
82 }
83 kunit_assert_print_msg(assert, stream);
84}
85EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
86
87void kunit_binary_assert_format(const struct kunit_assert *assert,
88 struct string_stream *stream)
89{
90 struct kunit_binary_assert *binary_assert = container_of(
91 assert, struct kunit_binary_assert, assert);
92
93 kunit_base_assert_format(assert, stream);
94 string_stream_add(stream,
95 "\tExpected %s %s %s, but\n",
96 binary_assert->left_text,
97 binary_assert->operation,
98 binary_assert->right_text);
99 string_stream_add(stream, "\t\t%s == %lld\n",
100 binary_assert->left_text,
101 binary_assert->left_value);
102 string_stream_add(stream, "\t\t%s == %lld",
103 binary_assert->right_text,
104 binary_assert->right_value);
105 kunit_assert_print_msg(assert, stream);
106}
107EXPORT_SYMBOL_GPL(kunit_binary_assert_format);
108
109void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
110 struct string_stream *stream)
111{
112 struct kunit_binary_ptr_assert *binary_assert = container_of(
113 assert, struct kunit_binary_ptr_assert, assert);
114
115 kunit_base_assert_format(assert, stream);
116 string_stream_add(stream,
117 "\tExpected %s %s %s, but\n",
118 binary_assert->left_text,
119 binary_assert->operation,
120 binary_assert->right_text);
121 string_stream_add(stream, "\t\t%s == %pK\n",
122 binary_assert->left_text,
123 binary_assert->left_value);
124 string_stream_add(stream, "\t\t%s == %pK",
125 binary_assert->right_text,
126 binary_assert->right_value);
127 kunit_assert_print_msg(assert, stream);
128}
129EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
130
131void kunit_binary_str_assert_format(const struct kunit_assert *assert,
132 struct string_stream *stream)
133{
134 struct kunit_binary_str_assert *binary_assert = container_of(
135 assert, struct kunit_binary_str_assert, assert);
136
137 kunit_base_assert_format(assert, stream);
138 string_stream_add(stream,
139 "\tExpected %s %s %s, but\n",
140 binary_assert->left_text,
141 binary_assert->operation,
142 binary_assert->right_text);
143 string_stream_add(stream, "\t\t%s == %s\n",
144 binary_assert->left_text,
145 binary_assert->left_value);
146 string_stream_add(stream, "\t\t%s == %s",
147 binary_assert->right_text,
148 binary_assert->right_value);
149 kunit_assert_print_msg(assert, stream);
150}
151EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);