2019-09-23 09:02:34 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
/*
|
|
|
|
* Assertion and expectation serialization API.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2019, Google LLC.
|
|
|
|
* Author: Brendan Higgins <brendanhiggins@google.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _KUNIT_ASSERT_H
|
|
|
|
#define _KUNIT_ASSERT_H
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
2022-01-20 02:09:19 +00:00
|
|
|
#include <linux/printk.h>
|
2019-09-23 09:02:34 +00:00
|
|
|
|
|
|
|
struct kunit;
|
2020-01-06 22:28:18 +00:00
|
|
|
struct string_stream;
|
2019-09-23 09:02:34 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* enum kunit_assert_type - Type of expectation/assertion.
|
|
|
|
* @KUNIT_ASSERTION: Used to denote that a kunit_assert represents an assertion.
|
|
|
|
* @KUNIT_EXPECTATION: Denotes that a kunit_assert represents an expectation.
|
|
|
|
*
|
|
|
|
* Used in conjunction with a &struct kunit_assert to denote whether it
|
|
|
|
* represents an expectation or an assertion.
|
|
|
|
*/
|
|
|
|
enum kunit_assert_type {
|
|
|
|
KUNIT_ASSERTION,
|
|
|
|
KUNIT_EXPECTATION,
|
|
|
|
};
|
|
|
|
|
kunit: split out part of kunit_assert into a static const
This is per Linus's suggestion in [1].
The issue there is that every KUNIT_EXPECT/KUNIT_ASSERT puts a
kunit_assert object onto the stack. Normally we rely on compilers to
elide this, but when that doesn't work out, this blows up the stack
usage of kunit test functions.
We can move some data off the stack by making it static.
This change introduces a new `struct kunit_loc` to hold the file and
line number and then just passing assert_type (EXPECT or ASSERT) as an
argument.
In [1], it was suggested to also move out the format string as well, but
users could theoretically craft a format string at runtime, so we can't.
This change leaves a copy of `assert_type` in kunit_assert for now
because cleaning up all the macros to not pass it around is a bit more
involved.
Here's an example of the expanded code for KUNIT_FAIL():
if (__builtin_expect(!!(!(false)), 0)) {
static const struct kunit_loc loc = { .file = ... };
struct kunit_fail_assert __assertion = { .assert = { .type ... };
kunit_do_failed_assertion(test, &loc, KUNIT_EXPECTATION, &__assertion.assert, ...);
};
[1] https://groups.google.com/g/kunit-dev/c/i3fZXgvBrfA/m/VULQg1z6BAAJ
Signed-off-by: Daniel Latypov <dlatypov@google.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Reviewed-by: David Gow <davidgow@google.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
2022-01-13 16:59:30 +00:00
|
|
|
/**
|
|
|
|
* struct kunit_loc - Identifies the source location of a line of code.
|
|
|
|
* @line: the line number in the file.
|
|
|
|
* @file: the file name.
|
|
|
|
*/
|
|
|
|
struct kunit_loc {
|
|
|
|
int line;
|
|
|
|
const char *file;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define KUNIT_CURRENT_LOC { .file = __FILE__, .line = __LINE__ }
|
|
|
|
|
2019-09-23 09:02:34 +00:00
|
|
|
/**
|
|
|
|
* struct kunit_assert - Data for printing a failed assertion or expectation.
|
|
|
|
* @type: the type (either an expectation or an assertion) of this kunit_assert.
|
|
|
|
* @message: an optional message to provide additional context.
|
|
|
|
* @format: a function which formats the data in this kunit_assert to a string.
|
|
|
|
*
|
|
|
|
* Represents a failed expectation/assertion. Contains all the data necessary to
|
|
|
|
* format a string to a user reporting the failure.
|
|
|
|
*/
|
|
|
|
struct kunit_assert {
|
kunit: split out part of kunit_assert into a static const
This is per Linus's suggestion in [1].
The issue there is that every KUNIT_EXPECT/KUNIT_ASSERT puts a
kunit_assert object onto the stack. Normally we rely on compilers to
elide this, but when that doesn't work out, this blows up the stack
usage of kunit test functions.
We can move some data off the stack by making it static.
This change introduces a new `struct kunit_loc` to hold the file and
line number and then just passing assert_type (EXPECT or ASSERT) as an
argument.
In [1], it was suggested to also move out the format string as well, but
users could theoretically craft a format string at runtime, so we can't.
This change leaves a copy of `assert_type` in kunit_assert for now
because cleaning up all the macros to not pass it around is a bit more
involved.
Here's an example of the expanded code for KUNIT_FAIL():
if (__builtin_expect(!!(!(false)), 0)) {
static const struct kunit_loc loc = { .file = ... };
struct kunit_fail_assert __assertion = { .assert = { .type ... };
kunit_do_failed_assertion(test, &loc, KUNIT_EXPECTATION, &__assertion.assert, ...);
};
[1] https://groups.google.com/g/kunit-dev/c/i3fZXgvBrfA/m/VULQg1z6BAAJ
Signed-off-by: Daniel Latypov <dlatypov@google.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Reviewed-by: David Gow <davidgow@google.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
2022-01-13 16:59:30 +00:00
|
|
|
// TODO(dlatypov@google.com): delete this unused field when we've
|
|
|
|
// updated all the related KUNIT_INIT_ASSERT* macros.
|
2019-09-23 09:02:34 +00:00
|
|
|
enum kunit_assert_type type;
|
|
|
|
struct va_format message;
|
|
|
|
void (*format)(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_VA_FMT_NULL - Default initializer for struct va_format.
|
|
|
|
*
|
|
|
|
* Used inside a struct initialization block to initialize struct va_format to
|
|
|
|
* default values where fmt and va are null.
|
|
|
|
*/
|
|
|
|
#define KUNIT_INIT_VA_FMT_NULL { .fmt = NULL, .va = NULL }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_ASSERT_STRUCT() - Initializer for a &struct kunit_assert.
|
|
|
|
* @assert_type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @fmt: The formatting function which builds a string out of this kunit_assert.
|
|
|
|
*
|
|
|
|
* The base initializer for a &struct kunit_assert.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_ASSERT_STRUCT(assert_type, fmt) { \
|
2019-09-23 09:02:34 +00:00
|
|
|
.type = assert_type, \
|
|
|
|
.message = KUNIT_INIT_VA_FMT_NULL, \
|
|
|
|
.format = fmt \
|
|
|
|
}
|
|
|
|
|
kunit: split out part of kunit_assert into a static const
This is per Linus's suggestion in [1].
The issue there is that every KUNIT_EXPECT/KUNIT_ASSERT puts a
kunit_assert object onto the stack. Normally we rely on compilers to
elide this, but when that doesn't work out, this blows up the stack
usage of kunit test functions.
We can move some data off the stack by making it static.
This change introduces a new `struct kunit_loc` to hold the file and
line number and then just passing assert_type (EXPECT or ASSERT) as an
argument.
In [1], it was suggested to also move out the format string as well, but
users could theoretically craft a format string at runtime, so we can't.
This change leaves a copy of `assert_type` in kunit_assert for now
because cleaning up all the macros to not pass it around is a bit more
involved.
Here's an example of the expanded code for KUNIT_FAIL():
if (__builtin_expect(!!(!(false)), 0)) {
static const struct kunit_loc loc = { .file = ... };
struct kunit_fail_assert __assertion = { .assert = { .type ... };
kunit_do_failed_assertion(test, &loc, KUNIT_EXPECTATION, &__assertion.assert, ...);
};
[1] https://groups.google.com/g/kunit-dev/c/i3fZXgvBrfA/m/VULQg1z6BAAJ
Signed-off-by: Daniel Latypov <dlatypov@google.com>
Suggested-by: Linus Torvalds <torvalds@linux-foundation.org>
Reviewed-by: David Gow <davidgow@google.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
2022-01-13 16:59:30 +00:00
|
|
|
void kunit_assert_prologue(const struct kunit_loc *loc,
|
|
|
|
enum kunit_assert_type type,
|
|
|
|
struct string_stream *stream);
|
2019-09-23 09:02:34 +00:00
|
|
|
|
|
|
|
void kunit_assert_print_msg(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_fail_assert - Represents a plain fail expectation/assertion.
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
*
|
|
|
|
* Represents a simple KUNIT_FAIL/KUNIT_ASSERT_FAILURE that always fails.
|
|
|
|
*/
|
|
|
|
struct kunit_fail_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_fail_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_FAIL_ASSERT_STRUCT() - Initializer for &struct kunit_fail_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_fail_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_FAIL_ASSERT_STRUCT(type) { \
|
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_fail_assert_format) \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_unary_assert - Represents a KUNIT_{EXPECT|ASSERT}_{TRUE|FALSE}
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
* @condition: A string representation of a conditional expression.
|
|
|
|
* @expected_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwise.
|
|
|
|
*
|
|
|
|
* Represents a simple expectation or assertion that simply asserts something is
|
|
|
|
* true or false. In other words, represents the expectations:
|
|
|
|
* KUNIT_{EXPECT|ASSERT}_{TRUE|FALSE}
|
|
|
|
*/
|
|
|
|
struct kunit_unary_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
const char *condition;
|
|
|
|
bool expected_true;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_unary_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_UNARY_ASSERT_STRUCT() - Initializes &struct kunit_unary_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @cond: A string representation of the expression asserted true or false.
|
|
|
|
* @expect_true: True if of type KUNIT_{EXPECT|ASSERT}_TRUE, false otherwise.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_unary_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_UNARY_ASSERT_STRUCT(type, cond, expect_true) { \
|
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_unary_assert_format), \
|
|
|
|
.condition = cond, \
|
|
|
|
.expected_true = expect_true \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_ptr_not_err_assert - An expectation/assertion that a pointer is
|
|
|
|
* not NULL and not a -errno.
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
* @text: A string representation of the expression passed to the expectation.
|
|
|
|
* @value: The actual evaluated pointer value of the expression.
|
|
|
|
*
|
|
|
|
* Represents an expectation/assertion that a pointer is not null and is does
|
|
|
|
* not contain a -errno. (See IS_ERR_OR_NULL().)
|
|
|
|
*/
|
|
|
|
struct kunit_ptr_not_err_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
const char *text;
|
|
|
|
const void *value;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_ptr_not_err_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_PTR_NOT_ERR_ASSERT_STRUCT() - Initializes a
|
|
|
|
* &struct kunit_ptr_not_err_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @txt: A string representation of the expression passed to the expectation.
|
|
|
|
* @val: The actual evaluated pointer value of the expression.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_ptr_not_err_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_PTR_NOT_ERR_STRUCT(type, txt, val) { \
|
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_ptr_not_err_assert_format), \
|
|
|
|
.text = txt, \
|
|
|
|
.value = val \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_binary_assert - An expectation/assertion that compares two
|
|
|
|
* non-pointer values (for example, KUNIT_EXPECT_EQ(test, 1 + 1, 2)).
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
* @operation: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_text: A string representation of the expression in the left slot.
|
|
|
|
* @left_value: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_text: A string representation of the expression in the right slot.
|
|
|
|
* @right_value: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Represents an expectation/assertion that compares two non-pointer values. For
|
|
|
|
* example, to expect that 1 + 1 == 2, you can use the expectation
|
|
|
|
* KUNIT_EXPECT_EQ(test, 1 + 1, 2);
|
|
|
|
*/
|
|
|
|
struct kunit_binary_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
const char *operation;
|
|
|
|
const char *left_text;
|
|
|
|
long long left_value;
|
|
|
|
const char *right_text;
|
|
|
|
long long right_value;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_binary_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_BINARY_ASSERT_STRUCT() - Initializes a
|
|
|
|
* &struct kunit_binary_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @op_str: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_str: A string representation of the expression in the left slot.
|
|
|
|
* @left_val: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_str: A string representation of the expression in the right slot.
|
|
|
|
* @right_val: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_binary_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_BINARY_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
op_str, \
|
|
|
|
left_str, \
|
|
|
|
left_val, \
|
|
|
|
right_str, \
|
|
|
|
right_val) { \
|
2022-01-13 16:59:28 +00:00
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_binary_assert_format), \
|
|
|
|
.operation = op_str, \
|
|
|
|
.left_text = left_str, \
|
|
|
|
.left_value = left_val, \
|
|
|
|
.right_text = right_str, \
|
|
|
|
.right_value = right_val \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_binary_ptr_assert - An expectation/assertion that compares two
|
|
|
|
* pointer values (for example, KUNIT_EXPECT_PTR_EQ(test, foo, bar)).
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
* @operation: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_text: A string representation of the expression in the left slot.
|
|
|
|
* @left_value: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_text: A string representation of the expression in the right slot.
|
|
|
|
* @right_value: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Represents an expectation/assertion that compares two pointer values. For
|
|
|
|
* example, to expect that foo and bar point to the same thing, you can use the
|
|
|
|
* expectation KUNIT_EXPECT_PTR_EQ(test, foo, bar);
|
|
|
|
*/
|
|
|
|
struct kunit_binary_ptr_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
const char *operation;
|
|
|
|
const char *left_text;
|
|
|
|
const void *left_value;
|
|
|
|
const char *right_text;
|
|
|
|
const void *right_value;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_binary_ptr_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT() - Initializes a
|
|
|
|
* &struct kunit_binary_ptr_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @op_str: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_str: A string representation of the expression in the left slot.
|
|
|
|
* @left_val: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_str: A string representation of the expression in the right slot.
|
|
|
|
* @right_val: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_binary_ptr_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
op_str, \
|
|
|
|
left_str, \
|
|
|
|
left_val, \
|
|
|
|
right_str, \
|
|
|
|
right_val) { \
|
2022-01-13 16:59:28 +00:00
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_binary_ptr_assert_format), \
|
|
|
|
.operation = op_str, \
|
|
|
|
.left_text = left_str, \
|
|
|
|
.left_value = left_val, \
|
|
|
|
.right_text = right_str, \
|
|
|
|
.right_value = right_val \
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct kunit_binary_str_assert - An expectation/assertion that compares two
|
|
|
|
* string values (for example, KUNIT_EXPECT_STREQ(test, foo, "bar")).
|
|
|
|
* @assert: The parent of this type.
|
|
|
|
* @operation: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_text: A string representation of the expression in the left slot.
|
|
|
|
* @left_value: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_text: A string representation of the expression in the right slot.
|
|
|
|
* @right_value: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Represents an expectation/assertion that compares two string values. For
|
|
|
|
* example, to expect that the string in foo is equal to "bar", you can use the
|
|
|
|
* expectation KUNIT_EXPECT_STREQ(test, foo, "bar");
|
|
|
|
*/
|
|
|
|
struct kunit_binary_str_assert {
|
|
|
|
struct kunit_assert assert;
|
|
|
|
const char *operation;
|
|
|
|
const char *left_text;
|
|
|
|
const char *left_value;
|
|
|
|
const char *right_text;
|
|
|
|
const char *right_value;
|
|
|
|
};
|
|
|
|
|
|
|
|
void kunit_binary_str_assert_format(const struct kunit_assert *assert,
|
|
|
|
struct string_stream *stream);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* KUNIT_INIT_BINARY_STR_ASSERT_STRUCT() - Initializes a
|
|
|
|
* &struct kunit_binary_str_assert.
|
|
|
|
* @type: The type (assertion or expectation) of this kunit_assert.
|
|
|
|
* @op_str: A string representation of the comparison operator (e.g. "==").
|
|
|
|
* @left_str: A string representation of the expression in the left slot.
|
|
|
|
* @left_val: The actual evaluated value of the expression in the left slot.
|
|
|
|
* @right_str: A string representation of the expression in the right slot.
|
|
|
|
* @right_val: The actual evaluated value of the expression in the right slot.
|
|
|
|
*
|
|
|
|
* Initializes a &struct kunit_binary_str_assert. Intended to be used in
|
|
|
|
* KUNIT_EXPECT_* and KUNIT_ASSERT_* macros.
|
|
|
|
*/
|
2022-01-13 16:59:28 +00:00
|
|
|
#define KUNIT_INIT_BINARY_STR_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
op_str, \
|
|
|
|
left_str, \
|
|
|
|
left_val, \
|
|
|
|
right_str, \
|
|
|
|
right_val) { \
|
2022-01-13 16:59:28 +00:00
|
|
|
.assert = KUNIT_INIT_ASSERT_STRUCT(type, \
|
2019-09-23 09:02:34 +00:00
|
|
|
kunit_binary_str_assert_format), \
|
|
|
|
.operation = op_str, \
|
|
|
|
.left_text = left_str, \
|
|
|
|
.left_value = left_val, \
|
|
|
|
.right_text = right_str, \
|
|
|
|
.right_value = right_val \
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* _KUNIT_ASSERT_H */
|