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 10 #include "string-stream.h" 11 12 void 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 } 29 EXPORT_SYMBOL_GPL(kunit_base_assert_format); 30 31 void 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 } 37 EXPORT_SYMBOL_GPL(kunit_assert_print_msg); 38 39 void 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 } 45 EXPORT_SYMBOL_GPL(kunit_fail_assert_format); 46 47 void 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 } 64 EXPORT_SYMBOL_GPL(kunit_unary_assert_format); 65 66 void 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 } 85 EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format); 86 87 void 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 } 107 EXPORT_SYMBOL_GPL(kunit_binary_assert_format); 108 109 void 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 } 129 EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format); 130 131 void 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 } 151 EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format); 152