blob: 5d44f71b131a208ee33a648af75fd44f30d7a188 [file] [log] [blame]
#include <test/mock.h>
static int mock_void_ptr_init(struct MOCK(void) *mock_void_ptr)
{
mock_void_ptr->trgt = mock_void_ptr;
return 0;
}
DEFINE_STRUCT_CLASS_MOCK_INIT(void, mock_void_ptr_init);
static bool mock_match_params(struct mock_matcher *matcher,
struct test_stream *stream,
const void **params,
int len)
{
struct mock_param_matcher *param_matcher;
bool ret = true, tmp;
int i;
BUG_ON(matcher->num != len);
for (i = 0; i < matcher->num; i++) {
param_matcher = matcher->matchers[i];
stream->add(stream, "\t");
tmp = param_matcher->match(param_matcher, stream, params[i]);
ret = ret && tmp;
stream->add(stream, "\n");
}
return ret;
}
static const void *mock_do_expect(struct mock *mock,
const char *method_name,
const void *method_ptr,
const char * const *type_names,
const void **params,
int len);
static bool mock_is_expectation_satisfied(struct mock_expectation *expectation)
{
return (expectation->min_calls_expected <= expectation->times_called &&
expectation->times_called <= expectation->max_calls_expected);
}
static void mock_write_expectation_unsatisfied_message(
struct mock_expectation *expectation,
struct test_stream *stream)
{
stream->add(stream,
"Expectation was not called the specified number of times:\n\t");
stream->add(stream,
"Function: %s, min calls: %d, max calls: %d, actual calls: %d",
expectation->method->method_name,
expectation->min_calls_expected,
expectation->max_calls_expected,
expectation->times_called);
}
void mock_validate_expectations(struct mock *mock)
{
struct mock_expectation *expectation, *expectation_safe;
struct mock_method *method;
struct test_stream *stream;
stream = test_new_stream(mock->test);
list_for_each_entry(method, &mock->methods, node) {
list_for_each_entry_safe(expectation, expectation_safe,
&method->expectations, node) {
if (!mock_is_expectation_satisfied(expectation)) {
mock_write_expectation_unsatisfied_message(
expectation, stream);
mock->test->fail(mock->test, stream);
}
list_del(&expectation->node);
}
}
}
static void mock_validate_wrapper(struct test_post_condition *condition)
{
struct mock *mock = container_of(condition, struct mock, parent);
mock_validate_expectations(mock);
}
void mock_init_ctrl(struct test *test, struct mock *mock)
{
mock->test = test;
INIT_LIST_HEAD(&mock->methods);
mock->do_expect = mock_do_expect;
mock->type = DEFAULT_MOCK_TYPE;
mock->parent.validate = mock_validate_wrapper;
list_add_tail(&mock->parent.node, &test->post_conditions);
}
struct global_mock {
struct mock ctrl;
bool is_initialized;
};
static struct global_mock global_mock = {
.is_initialized = false,
};
static int mock_init_global_mock(struct test_initcall *initcall,
struct test *test)
{
BUG_ON(global_mock.is_initialized);
mock_init_ctrl(test, &global_mock.ctrl);
global_mock.is_initialized = true;
return 0;
}
static void mock_exit_global_mock(struct test_initcall *initcall)
{
BUG_ON(!global_mock.is_initialized);
global_mock.ctrl.test = NULL;
global_mock.is_initialized = false;
}
static struct test_initcall global_mock_initcall = {
.init = mock_init_global_mock,
.exit = mock_exit_global_mock,
};
test_register_initcall(global_mock_initcall);
struct mock *mock_get_global_mock(void)
{
BUG_ON(!global_mock.is_initialized);
return &global_mock.ctrl;
}
static struct mock_method *mock_lookup_method(struct mock *mock,
const void *method_ptr)
{
struct mock_method *ret;
list_for_each_entry(ret, &mock->methods, node) {
if (ret->method_ptr == method_ptr)
return ret;
}
return NULL;
}
static struct mock_method *mock_add_method(struct mock *mock,
const char *method_name,
const void *method_ptr)
{
struct mock_method *method;
method = test_kzalloc(mock->test, sizeof(*method), GFP_KERNEL);
if (!method)
return NULL;
INIT_LIST_HEAD(&method->expectations);
method->method_name = method_name;
method->method_ptr = method_ptr;
list_add_tail(&method->node, &mock->methods);
return method;
}
static int mock_add_expectation(struct mock *mock,
const char *method_name,
const void *method_ptr,
struct mock_expectation *expectation)
{
struct mock_method *method;
method = mock_lookup_method(mock, method_ptr);
if (!method) {
method = mock_add_method(mock, method_name, method_ptr);
if (!method)
return -ENOMEM;
}
list_add_tail(&expectation->node, &method->expectations);
expectation->method = method;
return 0;
}
struct mock_expectation *mock_add_matcher(struct mock *mock,
const char *method_name,
const void *method_ptr,
struct mock_param_matcher *matchers[],
int len)
{
struct mock_expectation *expectation;
struct mock_matcher *matcher;
int ret;
expectation = test_kzalloc(mock->test,
sizeof(*expectation),
GFP_KERNEL);
if (!expectation)
return NULL;
matcher = test_kmalloc(mock->test, sizeof(*matcher), GFP_KERNEL);
if (!matcher)
return NULL;
memcpy(&matcher->matchers, matchers, sizeof(*matchers) * len);
matcher->num = len;
expectation->matcher = matcher;
expectation->max_calls_expected = 1;
expectation->min_calls_expected = 1;
INIT_LIST_HEAD(&expectation->prerequisites);
ret = mock_add_expectation(mock, method_name, method_ptr, expectation);
if (ret < 0)
return NULL;
return expectation;
}
int mock_set_default_action(struct mock *mock,
const char *method_name,
const void *method_ptr,
struct mock_action *action)
{
struct mock_method *method;
method = mock_lookup_method(mock, method_ptr);
if (!method) {
method = mock_add_method(mock, method_name, method_ptr);
if (!method)
return -ENOMEM;
}
method->default_action = action;
return 0;
}
struct mock_param_formatter_repo {
struct list_head formatters;
};
static struct mock_param_formatter_repo mock_param_formatter_repo = {
.formatters = LIST_HEAD_INIT(mock_param_formatter_repo.formatters),
};
void mock_register_formatter(struct mock_param_formatter *formatter)
{
list_add_tail(&formatter->node, &mock_param_formatter_repo.formatters);
}
void mock_unregister_formatter(struct mock_param_formatter *formatter)
{
list_del(&formatter->node);
}
struct mock_param_formatter *mock_find_formatter(const char *type_name)
{
struct mock_param_formatter *formatter;
list_for_each_entry(formatter,
&mock_param_formatter_repo.formatters,
node) {
if (!strcmp(type_name, formatter->type_name))
return formatter;
}
return NULL;
}
static void mock_format_param(struct test_stream *stream,
const char *type_name,
const void *param)
{
struct mock_param_formatter *formatter;
formatter = mock_find_formatter(type_name);
if (formatter)
formatter->format(formatter, stream, param);
else
/*
* Cannot find formatter, so just print the pointer of the
* symbol.
*/
stream->add(stream, "<%pS>", param);
}
static void mock_add_method_declaration_to_stream(
struct test_stream *stream,
const char *function_name,
const char * const *type_names,
const void **params,
int len)
{
int i;
stream->add(stream, "%s(", function_name);
for (i = 0; i < len; i++) {
mock_format_param(stream, type_names[i], params[i]);
if (i < len - 1)
stream->add(stream, ", ");
}
stream->add(stream, ")\n");
}
static struct test_stream *mock_initialize_failure_message(
struct test *test,
const char *function_name,
const char * const *type_names,
const void **params,
int len)
{
struct test_stream *stream;
stream = test_new_stream(test);
if (!stream)
return NULL;
stream->add(stream, "EXPECTATION FAILED: no expectation for call: ");
mock_add_method_declaration_to_stream(stream,
function_name,
type_names,
params,
len);
return stream;
}
static bool mock_is_expectation_retired(struct mock_expectation *expectation)
{
return expectation->retire_on_saturation &&
expectation->times_called ==
expectation->max_calls_expected;
}
static void mock_add_method_expectation_error(struct test *test,
struct test_stream *stream,
char *message,
struct mock *mock,
struct mock_method *method,
const char * const *type_names,
const void **params,
int len)
{
stream->clear(stream);
stream->set_level(stream, KERN_WARNING);
stream->add(stream, message);
mock_add_method_declaration_to_stream(stream,
method->method_name, type_names, params, len);
}
static bool mock_are_prereqs_satisfied(struct mock_expectation *expectation,
struct test_stream *stream)
{
struct mock_expectation_prereq_entry *entry, *entry_safe;
list_for_each_entry_safe(entry, entry_safe,
&expectation->prerequisites, node) {
if (!mock_is_expectation_satisfied(entry->expectation)) {
stream->add(stream,
"Expectation %s matched but prerequisite expectation was not satisfied:\n",
expectation->expectation_name);
mock_write_expectation_unsatisfied_message(
entry->expectation, stream);
return false;
}
/* Don't need to check satisfied prereq again. */
list_del(&entry->node);
}
return true;
}
/* Assumes that the var args are null terminated. */
int mock_in_sequence(struct test *test, struct mock_expectation *first, ...)
{
struct mock_expectation *prereq = first;
struct mock_expectation *curr = NULL;
struct mock_expectation_prereq_entry *entry;
va_list args;
va_start(args, first);
while ((curr = va_arg(args, struct mock_expectation*))) {
entry = test_kzalloc(test, sizeof(*entry), GFP_KERNEL);
if (!entry) {
va_end(args);
return -ENOMEM;
}
entry->expectation = prereq;
list_add_tail(&entry->node, &curr->prerequisites);
prereq = curr;
}
va_end(args);
return 0;
}
static inline bool does_mock_expectation_match_call(
struct mock_expectation *expectation,
struct test_stream *stream,
const void **params,
int len)
{
return mock_match_params(expectation->matcher, stream, params, len) &&
mock_are_prereqs_satisfied(expectation, stream);
}
static struct mock_expectation *mock_apply_expectations(
struct mock *mock,
struct mock_method *method,
const char * const *type_names,
const void **params,
int len)
{
struct test *test = mock->test;
struct mock_expectation *ret;
struct test_stream *attempted_matching_stream;
bool expectations_all_saturated = true;
struct test_stream *stream = test_new_stream(test);
if (list_empty(&method->expectations)) {
mock_add_method_expectation_error(test, stream,
"Method was called with no expectations declared: ",
mock, method, type_names, params, len);
if (is_strict_mock(mock))
test->fail(test, stream);
else if (is_naggy_mock(mock))
stream->commit(stream);
else
stream->clear(stream);
return NULL;
}
attempted_matching_stream = mock_initialize_failure_message(
test,
method->method_name,
type_names,
params,
len);
list_for_each_entry(ret, &method->expectations, node) {
if (mock_is_expectation_retired(ret))
continue;
expectations_all_saturated = false;
attempted_matching_stream->add(attempted_matching_stream,
"Tried expectation: %s, but\n", ret->expectation_name);
if (does_mock_expectation_match_call(ret,
attempted_matching_stream, params, len)) {
/*
* Matcher was found; we won't print, so clean up the
* log.
*/
attempted_matching_stream->clear(
attempted_matching_stream);
return ret;
}
}
if (expectations_all_saturated && !is_nice_mock(mock)) {
mock_add_method_expectation_error(test, stream,
"Method was called with fully saturated expectations: ",
mock, method, type_names, params, len);
} else {
mock_add_method_expectation_error(test, stream,
"Method called that did not match any expectations: ",
mock, method, type_names, params, len);
stream->append(stream, attempted_matching_stream);
}
test->fail(test, stream);
attempted_matching_stream->clear(attempted_matching_stream);
return NULL;
}
static const void *mock_do_expect(struct mock *mock,
const char *method_name,
const void *method_ptr,
const char * const *param_types,
const void **params,
int len)
{
struct mock_expectation *expectation;
struct mock_method *method;
struct mock_action *action;
method = mock_lookup_method(mock, method_ptr);
if (!method)
return NULL;
expectation = mock_apply_expectations(mock,
method,
param_types,
params,
len);
if (!expectation) {
action = method->default_action;
} else {
expectation->times_called++;
if (expectation->action)
action = expectation->action;
else
action = method->default_action;
}
if (!action)
return NULL;
return action->do_action(action, params, len);
}