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 9 #ifndef _KUNIT_ASSERT_H 10 #define _KUNIT_ASSERT_H 11 12 #include <linux/err.h> 13 #include <linux/printk.h> 14 15 struct kunit; 16 struct string_stream; 17 18 /** 19 * enum kunit_assert_type - Type of expectation/assertion. 20 * @KUNIT_ASSERTION: Used to denote that a kunit_assert represents an assertion. 21 * @KUNIT_EXPECTATION: Denotes that a kunit_assert represents an expectation. 22 * 23 * Used in conjunction with a &struct kunit_assert to denote whether it 24 * represents an expectation or an assertion. 25 */ 26 enum kunit_assert_type { 27 KUNIT_ASSERTION, 28 KUNIT_EXPECTATION, 29 }; 30 31 /** 32 * struct kunit_loc - Identifies the source location of a line of code. 33 * @line: the line number in the file. 34 * @file: the file name. 35 */ 36 struct kunit_loc { 37 int line; 38 const char *file; 39 }; 40 41 #define KUNIT_CURRENT_LOC { .file = __FILE__, .line = __LINE__ } 42 43 /** 44 * struct kunit_assert - Data for printing a failed assertion or expectation. 45 * 46 * Represents a failed expectation/assertion. Contains all the data necessary to 47 * format a string to a user reporting the failure. 48 */ 49 struct kunit_assert {}; 50 51 typedef void (*assert_format_t)(const struct kunit_assert *assert, 52 const struct va_format *message, 53 struct string_stream *stream); 54 55 void kunit_assert_prologue(const struct kunit_loc *loc, 56 enum kunit_assert_type type, 57 struct string_stream *stream); 58 59 /** 60 * struct kunit_fail_assert - Represents a plain fail expectation/assertion. 61 * @assert: The parent of this type. 62 * 63 * Represents a simple KUNIT_FAIL/KUNIT_ASSERT_FAILURE that always fails. 64 */ 65 struct kunit_fail_assert { 66 struct kunit_assert assert; 67 }; 68 69 void kunit_fail_assert_format(const struct kunit_assert *assert, 70 const struct va_format *message, 71 struct string_stream *stream); 72 73 /** 74 * struct kunit_unary_assert - Represents a KUNIT_{EXPECT|ASSERT}_{TRUE|FALSE} 75 * @assert: The parent of this type. 76 * @condition: A string representation of a conditional expression. 77 * @expected_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwise. 78 * 79 * Represents a simple expectation or assertion that simply asserts something is 80 * true or false. In other words, represents the expectations: 81 * KUNIT_{EXPECT|ASSERT}_{TRUE|FALSE} 82 */ 83 struct kunit_unary_assert { 84 struct kunit_assert assert; 85 const char *condition; 86 bool expected_true; 87 }; 88 89 void kunit_unary_assert_format(const struct kunit_assert *assert, 90 const struct va_format *message, 91 struct string_stream *stream); 92 93 /** 94 * struct kunit_ptr_not_err_assert - An expectation/assertion that a pointer is 95 * not NULL and not a -errno. 96 * @assert: The parent of this type. 97 * @text: A string representation of the expression passed to the expectation. 98 * @value: The actual evaluated pointer value of the expression. 99 * 100 * Represents an expectation/assertion that a pointer is not null and is does 101 * not contain a -errno. (See IS_ERR_OR_NULL().) 102 */ 103 struct kunit_ptr_not_err_assert { 104 struct kunit_assert assert; 105 const char *text; 106 const void *value; 107 }; 108 109 void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert, 110 const struct va_format *message, 111 struct string_stream *stream); 112 113 /** 114 * struct kunit_binary_assert_text - holds strings for &struct 115 * kunit_binary_assert and friends to try and make the structs smaller. 116 * @operation: A string representation of the comparison operator (e.g. "=="). 117 * @left_text: A string representation of the left expression (e.g. "2+2"). 118 * @right_text: A string representation of the right expression (e.g. "2+2"). 119 */ 120 struct kunit_binary_assert_text { 121 const char *operation; 122 const char *left_text; 123 const char *right_text; 124 }; 125 126 /** 127 * struct kunit_binary_assert - An expectation/assertion that compares two 128 * non-pointer values (for example, KUNIT_EXPECT_EQ(test, 1 + 1, 2)). 129 * @assert: The parent of this type. 130 * @text: Holds the textual representations of the operands and op (e.g. "=="). 131 * @left_value: The actual evaluated value of the expression in the left slot. 132 * @right_value: The actual evaluated value of the expression in the right slot. 133 * 134 * Represents an expectation/assertion that compares two non-pointer values. For 135 * example, to expect that 1 + 1 == 2, you can use the expectation 136 * KUNIT_EXPECT_EQ(test, 1 + 1, 2); 137 */ 138 struct kunit_binary_assert { 139 struct kunit_assert assert; 140 const struct kunit_binary_assert_text *text; 141 long long left_value; 142 long long right_value; 143 }; 144 145 void kunit_binary_assert_format(const struct kunit_assert *assert, 146 const struct va_format *message, 147 struct string_stream *stream); 148 149 /** 150 * struct kunit_binary_ptr_assert - An expectation/assertion that compares two 151 * pointer values (for example, KUNIT_EXPECT_PTR_EQ(test, foo, bar)). 152 * @assert: The parent of this type. 153 * @text: Holds the textual representations of the operands and op (e.g. "=="). 154 * @left_value: The actual evaluated value of the expression in the left slot. 155 * @right_value: The actual evaluated value of the expression in the right slot. 156 * 157 * Represents an expectation/assertion that compares two pointer values. For 158 * example, to expect that foo and bar point to the same thing, you can use the 159 * expectation KUNIT_EXPECT_PTR_EQ(test, foo, bar); 160 */ 161 struct kunit_binary_ptr_assert { 162 struct kunit_assert assert; 163 const struct kunit_binary_assert_text *text; 164 const void *left_value; 165 const void *right_value; 166 }; 167 168 void kunit_binary_ptr_assert_format(const struct kunit_assert *assert, 169 const struct va_format *message, 170 struct string_stream *stream); 171 172 /** 173 * struct kunit_binary_str_assert - An expectation/assertion that compares two 174 * string values (for example, KUNIT_EXPECT_STREQ(test, foo, "bar")). 175 * @assert: The parent of this type. 176 * @text: Holds the textual representations of the operands and comparator. 177 * @left_value: The actual evaluated value of the expression in the left slot. 178 * @right_value: The actual evaluated value of the expression in the right slot. 179 * 180 * Represents an expectation/assertion that compares two string values. For 181 * example, to expect that the string in foo is equal to "bar", you can use the 182 * expectation KUNIT_EXPECT_STREQ(test, foo, "bar"); 183 */ 184 struct kunit_binary_str_assert { 185 struct kunit_assert assert; 186 const struct kunit_binary_assert_text *text; 187 const char *left_value; 188 const char *right_value; 189 }; 190 191 void kunit_binary_str_assert_format(const struct kunit_assert *assert, 192 const struct va_format *message, 193 struct string_stream *stream); 194 195 /** 196 * struct kunit_mem_assert - An expectation/assertion that compares two 197 * memory blocks. 198 * @assert: The parent of this type. 199 * @text: Holds the textual representations of the operands and comparator. 200 * @left_value: The actual evaluated value of the expression in the left slot. 201 * @right_value: The actual evaluated value of the expression in the right slot. 202 * @size: Size of the memory block analysed in bytes. 203 * 204 * Represents an expectation/assertion that compares two memory blocks. For 205 * example, to expect that the first three bytes of foo is equal to the 206 * first three bytes of bar, you can use the expectation 207 * KUNIT_EXPECT_MEMEQ(test, foo, bar, 3); 208 */ 209 struct kunit_mem_assert { 210 struct kunit_assert assert; 211 const struct kunit_binary_assert_text *text; 212 const void *left_value; 213 const void *right_value; 214 const size_t size; 215 }; 216 217 void kunit_mem_assert_format(const struct kunit_assert *assert, 218 const struct va_format *message, 219 struct string_stream *stream); 220 221 #endif /* _KUNIT_ASSERT_H */ 222