lib/kunit/assert.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Assertion and expectation serialization API.
0004  *
0005  * Copyright (C) 2019, Google LLC.
0006  * Author: Brendan Higgins <brendanhiggins@google.com>
0007  */
0008 #include <kunit/assert.h>
0009 #include <kunit/test.h>
0010
0011 #include "string-stream.h"
0012
0013 void kunit_assert_prologue(const struct kunit_loc *loc,
0014                enum kunit_assert_type type,
0015                   struct string_stream *stream)
0016 {
0017     const char *expect_or_assert = NULL;
0018
0019     switch (type) {
0020     case KUNIT_EXPECTATION:
0021         expect_or_assert = "EXPECTATION";
0022         break;
0023     case KUNIT_ASSERTION:
0024         expect_or_assert = "ASSERTION";
0025         break;
0026     }
0027
0028     string_stream_add(stream, "%s FAILED at %s:%d\n",
0029               expect_or_assert, loc->file, loc->line);
0030 }
0031 EXPORT_SYMBOL_GPL(kunit_assert_prologue);
0032
0033 static void kunit_assert_print_msg(const struct va_format *message,
0034                    struct string_stream *stream)
0035 {
0036     if (message->fmt)
0037         string_stream_add(stream, "\n%pV", message);
0038 }
0039
0040 void kunit_fail_assert_format(const struct kunit_assert *assert,
0041                   const struct va_format *message,
0042                   struct string_stream *stream)
0043 {
0044     string_stream_add(stream, "%pV", message);
0045 }
0046 EXPORT_SYMBOL_GPL(kunit_fail_assert_format);
0047
0048 void kunit_unary_assert_format(const struct kunit_assert *assert,
0049                    const struct va_format *message,
0050                    struct string_stream *stream)
0051 {
0052     struct kunit_unary_assert *unary_assert;
0053
0054     unary_assert = container_of(assert, struct kunit_unary_assert, assert);
0055
0056     if (unary_assert->expected_true)
0057         string_stream_add(stream,
0058                   KUNIT_SUBTEST_INDENT "Expected %s to be true, but is false\n",
0059                   unary_assert->condition);
0060     else
0061         string_stream_add(stream,
0062                   KUNIT_SUBTEST_INDENT "Expected %s to be false, but is true\n",
0063                   unary_assert->condition);
0064     kunit_assert_print_msg(message, stream);
0065 }
0066 EXPORT_SYMBOL_GPL(kunit_unary_assert_format);
0067
0068 void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
0069                      const struct va_format *message,
0070                      struct string_stream *stream)
0071 {
0072     struct kunit_ptr_not_err_assert *ptr_assert;
0073
0074     ptr_assert = container_of(assert, struct kunit_ptr_not_err_assert,
0075                   assert);
0076
0077     if (!ptr_assert->value) {
0078         string_stream_add(stream,
0079                   KUNIT_SUBTEST_INDENT "Expected %s is not null, but is\n",
0080                   ptr_assert->text);
0081     } else if (IS_ERR(ptr_assert->value)) {
0082         string_stream_add(stream,
0083                   KUNIT_SUBTEST_INDENT "Expected %s is not error, but is: %ld\n",
0084                   ptr_assert->text,
0085                   PTR_ERR(ptr_assert->value));
0086     }
0087     kunit_assert_print_msg(message, stream);
0088 }
0089 EXPORT_SYMBOL_GPL(kunit_ptr_not_err_assert_format);
0090
0091 /* Checks if `text` is a literal representing `value`, e.g. "5" and 5 */
0092 static bool is_literal(struct kunit *test, const char *text, long long value,
0093                gfp_t gfp)
0094 {
0095     char *buffer;
0096     int len;
0097     bool ret;
0098
0099     len = snprintf(NULL, 0, "%lld", value);
0100     if (strlen(text) != len)
0101         return false;
0102
0103     buffer = kunit_kmalloc(test, len+1, gfp);
0104     if (!buffer)
0105         return false;
0106
0107     snprintf(buffer, len+1, "%lld", value);
0108     ret = strncmp(buffer, text, len) == 0;
0109
0110     kunit_kfree(test, buffer);
0111     return ret;
0112 }
0113
0114 void kunit_binary_assert_format(const struct kunit_assert *assert,
0115                 const struct va_format *message,
0116                 struct string_stream *stream)
0117 {
0118     struct kunit_binary_assert *binary_assert;
0119
0120     binary_assert = container_of(assert, struct kunit_binary_assert,
0121                      assert);
0122
0123     string_stream_add(stream,
0124               KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
0125               binary_assert->text->left_text,
0126               binary_assert->text->operation,
0127               binary_assert->text->right_text);
0128     if (!is_literal(stream->test, binary_assert->text->left_text,
0129             binary_assert->left_value, stream->gfp))
0130         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld\n",
0131                   binary_assert->text->left_text,
0132                   binary_assert->left_value);
0133     if (!is_literal(stream->test, binary_assert->text->right_text,
0134             binary_assert->right_value, stream->gfp))
0135         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %lld",
0136                   binary_assert->text->right_text,
0137                   binary_assert->right_value);
0138     kunit_assert_print_msg(message, stream);
0139 }
0140 EXPORT_SYMBOL_GPL(kunit_binary_assert_format);
0141
0142 void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
0143                     const struct va_format *message,
0144                     struct string_stream *stream)
0145 {
0146     struct kunit_binary_ptr_assert *binary_assert;
0147
0148     binary_assert = container_of(assert, struct kunit_binary_ptr_assert,
0149                      assert);
0150
0151     string_stream_add(stream,
0152               KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
0153               binary_assert->text->left_text,
0154               binary_assert->text->operation,
0155               binary_assert->text->right_text);
0156     string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px\n",
0157               binary_assert->text->left_text,
0158               binary_assert->left_value);
0159     string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == %px",
0160               binary_assert->text->right_text,
0161               binary_assert->right_value);
0162     kunit_assert_print_msg(message, stream);
0163 }
0164 EXPORT_SYMBOL_GPL(kunit_binary_ptr_assert_format);
0165
0166 /* Checks if KUNIT_EXPECT_STREQ() args were string literals.
0167  * Note: `text` will have ""s where as `value` will not.
0168  */
0169 static bool is_str_literal(const char *text, const char *value)
0170 {
0171     int len;
0172
0173     len = strlen(text);
0174     if (len < 2)
0175         return false;
0176     if (text[0] != '\"' || text[len - 1] != '\"')
0177         return false;
0178
0179     return strncmp(text + 1, value, len - 2) == 0;
0180 }
0181
0182 void kunit_binary_str_assert_format(const struct kunit_assert *assert,
0183                     const struct va_format *message,
0184                     struct string_stream *stream)
0185 {
0186     struct kunit_binary_str_assert *binary_assert;
0187
0188     binary_assert = container_of(assert, struct kunit_binary_str_assert,
0189                      assert);
0190
0191     string_stream_add(stream,
0192               KUNIT_SUBTEST_INDENT "Expected %s %s %s, but\n",
0193               binary_assert->text->left_text,
0194               binary_assert->text->operation,
0195               binary_assert->text->right_text);
0196     if (!is_str_literal(binary_assert->text->left_text, binary_assert->left_value))
0197         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"\n",
0198                   binary_assert->text->left_text,
0199                   binary_assert->left_value);
0200     if (!is_str_literal(binary_assert->text->right_text, binary_assert->right_value))
0201         string_stream_add(stream, KUNIT_SUBSUBTEST_INDENT "%s == \"%s\"",
0202                   binary_assert->text->right_text,
0203                   binary_assert->right_value);
0204     kunit_assert_print_msg(message, stream);
0205 }
0206 EXPORT_SYMBOL_GPL(kunit_binary_str_assert_format);