233 lines · 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 9#ifndef _KUNIT_ASSERT_H10#define _KUNIT_ASSERT_H11 12#include <linux/err.h>13#include <linux/printk.h>14 15struct kunit;16struct 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 it24 * represents an expectation or an assertion.25 */26enum 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 */36struct 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 to47 * format a string to a user reporting the failure.48 */49struct kunit_assert {};50 51typedef void (*assert_format_t)(const struct kunit_assert *assert,52 const struct va_format *message,53 struct string_stream *stream);54 55void 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_FAIL_AND_ABORT that always fails.64 */65struct kunit_fail_assert {66 struct kunit_assert assert;67};68 69void 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 is80 * true or false. In other words, represents the expectations:81 * KUNIT_{EXPECT|ASSERT}_{TRUE|FALSE}82 */83struct kunit_unary_assert {84 struct kunit_assert assert;85 const char *condition;86 bool expected_true;87};88 89void 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 is95 * 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 does101 * not contain a -errno. (See IS_ERR_OR_NULL().)102 */103struct kunit_ptr_not_err_assert {104 struct kunit_assert assert;105 const char *text;106 const void *value;107};108 109void 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 &struct115 * 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 */120struct 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 two128 * 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. For135 * example, to expect that 1 + 1 == 2, you can use the expectation136 * KUNIT_EXPECT_EQ(test, 1 + 1, 2);137 */138struct 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 145void 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 two151 * 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. For158 * example, to expect that foo and bar point to the same thing, you can use the159 * expectation KUNIT_EXPECT_PTR_EQ(test, foo, bar);160 */161struct 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 168void 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 two174 * 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. For181 * example, to expect that the string in foo is equal to "bar", you can use the182 * expectation KUNIT_EXPECT_STREQ(test, foo, "bar");183 */184struct 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 191void 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 two197 * 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. For205 * example, to expect that the first three bytes of foo is equal to the206 * first three bytes of bar, you can use the expectation207 * KUNIT_EXPECT_MEMEQ(test, foo, bar, 3);208 */209struct 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 217void kunit_mem_assert_format(const struct kunit_assert *assert,218 const struct va_format *message,219 struct string_stream *stream);220 221#if IS_ENABLED(CONFIG_KUNIT)222void kunit_assert_print_msg(const struct va_format *message,223 struct string_stream *stream);224bool is_literal(const char *text, long long value);225bool is_str_literal(const char *text, const char *value);226void kunit_assert_hexdump(struct string_stream *stream,227 const void *buf,228 const void *compared_buf,229 const size_t len);230#endif231 232#endif /* _KUNIT_ASSERT_H */233