void clear_mocks() {
if (global_expectation_queue != NULL) {
destroy_cgreen_vector(global_expectation_queue);
global_expectation_queue = NULL;
}
if (learned_mock_calls != NULL) {
int i;
for (i = 0; i < cgreen_vector_size(learned_mock_calls); i++) {
RecordedExpectation *expectation = (RecordedExpectation*)cgreen_vector_get(learned_mock_calls, i);
destroy_expectation(expectation);
}
destroy_cgreen_vector(learned_mock_calls);
learned_mock_calls = NULL;
}
}
static void destroy_expectation(RecordedExpectation *expectation) {
destroy_cgreen_vector(expectation->constraints);
expectation->constraints = NULL;
expectation->function = NULL;
expectation->test_file = NULL;
expectation->test_line = 0;
expectation->time_to_live = 0;
free(expectation);
}
void add_tests_(TestSuite *suite, const char *names, ...) {
CgreenVector *test_names = create_vector_of_names(names);
int i;
va_list tests;
va_start(tests, names);
for (i = 0; i < cgreen_vector_size(test_names); i++) {
add_test_(suite, (char *)(cgreen_vector_get(test_names, i)), va_arg(tests, CgreenTest *));
}
va_end(tests);
destroy_cgreen_vector(test_names);
}
void clear_mocks() {
if (result_queue != NULL) {
destroy_cgreen_vector(result_queue);
result_queue = NULL;
}
if (expectation_queue != NULL) {
destroy_cgreen_vector(expectation_queue);
expectation_queue = NULL;
}
if (unwanted_calls != NULL) {
destroy_cgreen_vector(unwanted_calls);
unwanted_calls = NULL;
}
if (disabled_mocks != NULL) {
destroy_cgreen_vector(disabled_mocks);
disabled_mocks = NULL;
}
if (enabled_mocks != NULL) {
destroy_cgreen_vector(enabled_mocks);
enabled_mocks = NULL;
}
all_mocks_disabled = 0;
}
bool constraint_is_for_parameter_in(const Constraint *constraint, const char *names) {
int i;
bool found = false;
CgreenVector *parameter_names = create_vector_of_names(names);
if (!is_parameter(constraint)) return false;
for (i = 0; i < cgreen_vector_size(parameter_names); i++) {
const char *mock_parameter_name = (const char *)cgreen_vector_get(parameter_names, i);
if (constraint_is_for_parameter(constraint, mock_parameter_name)) {
found = true;
break;
}
}
destroy_cgreen_vector(parameter_names);
return found;
}
intptr_t mock_(const char *function, const char *parameters, ...) {
RecordedExpectation *expectation = NULL;
unwanted_check(function);
expectation = find_expectation(function);
if (expectation != NULL) {
CgreenVector *names = create_vector_of_names(parameters);
int i;
va_list actual;
va_start(actual, parameters);
for (i = 0; i < cgreen_vector_size(names); i++) {
apply_any_constraints(expectation, (const char *)cgreen_vector_get(names, i), va_arg(actual, intptr_t));
}
va_end(actual);
destroy_cgreen_vector(names);
if (! expectation->should_keep) {
destroy_expectation(expectation);
}
}
return stubbed_result(function);
}
static void destroy_expectation(void *abstract) {
RecordedExpectation *expectation = (RecordedExpectation *)abstract;
destroy_cgreen_vector(expectation->constraints);
free(expectation);
}
intptr_t mock_(TestReporter* test_reporter, const char *function, const char *mock_file, int mock_line, const char *parameters, ...) {
va_list actuals;
CgreenVector *actual_values;
CgreenVector *parameter_names;
int failures_before_read_only_constraints_executed;
int failures_after_read_only_constraints_executed;
int i;
intptr_t stored_result;
RecordedExpectation *expectation = find_expectation(function);
va_start(actuals, parameters);
actual_values = create_vector_of_actuals(actuals, number_of_parameters_in(parameters));
va_end(actuals);
parameter_names = create_vector_of_names(parameters);
if (expectation == NULL) {
handle_missing_expectation_for(function, mock_file, mock_line, parameter_names, actual_values, test_reporter);
destroy_cgreen_vector(actual_values);
destroy_cgreen_vector(parameter_names);
return 0;
}
if (is_never_call(expectation)) {
report_violated_never_call(test_reporter, expectation);
destroy_cgreen_vector(actual_values);
destroy_cgreen_vector(parameter_names);
return 0;
}
ensure_successfully_mocked_calls_list_exists();
cgreen_vector_add(successfully_mocked_calls, (void*)function);
stored_result = stored_result_or_default_for(expectation->constraints);
for (i = 0; i < cgreen_vector_size(expectation->constraints); i++) {
Constraint *constraint = (Constraint *)cgreen_vector_get(expectation->constraints, i);
if (!is_parameter(constraint)) continue;
if (!constraint_is_for_parameter_in(constraint, parameters)) {
// if expectation parameter name isn't in parameter_names,
// fail test and skip applying constraints unlikely to match
report_mock_parameter_name_not_found(test_reporter, expectation, constraint->parameter_name);
destroy_expectation_if_time_to_die(expectation);
destroy_cgreen_vector(actual_values);
destroy_cgreen_vector(parameter_names);
return stored_result;
}
}
// if read-only constraints aren't matching, content-setting ones might corrupt memory
// apply read-only ones first, and if they don't fail, then do the deeper constraints
failures_before_read_only_constraints_executed = test_reporter->failures;
for (i = 0; i < cgreen_vector_size(parameter_names); i++) {
const char* parameter_name = (const char*)cgreen_vector_get(parameter_names, i);
uintptr_t actual = (uintptr_t)cgreen_vector_get(actual_values, i);
apply_any_read_only_parameter_constraints(expectation, parameter_name, actual, test_reporter);
}
failures_after_read_only_constraints_executed = test_reporter->failures;
// FIXME: this comparison doesn't work because only parent processes' pass/fail counts are updated,
// and even then only once they read from the pipe
if (failures_before_read_only_constraints_executed == failures_after_read_only_constraints_executed) {
for (i = 0; i < cgreen_vector_size(parameter_names); i++) {
const char* parameter_name = (const char*)cgreen_vector_get(parameter_names, i);
uintptr_t actual = (uintptr_t)cgreen_vector_get(actual_values, i);
apply_any_content_setting_parameter_constraints(expectation, parameter_name, actual, test_reporter);
}
}
destroy_cgreen_vector(parameter_names);
destroy_cgreen_vector(actual_values);
destroy_expectation_if_time_to_die(expectation);
return stored_result;
}
