f_state_t state_data = f_state_t_initialize;
{
- const f_status_t status = f_fss_apply_delimit(state_data, delimits, 0);
+ f_fss_apply_delimit(delimits, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
{
f_string_static_t empty = f_string_static_t_initialize;
- const f_status_t status = f_fss_apply_delimit(state_data, delimits, &empty);
+ f_fss_apply_delimit(delimits, &empty, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
for (uint8_t i = 0; i < 7; ++i) {
- const f_status_t status = f_fss_apply_delimit(state_data, delimitss[i], &tests[i]);
+ f_fss_apply_delimit(delimitss[i], &tests[i], &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(tests[i].used, expects[i].used);
for (uint8_t j = 0; j < tests[i].used; ++j) {
const f_string_range_t range = f_string_range_t_initialize;
{
- const f_status_t status = f_fss_apply_delimit_range(state_data, delimits, range, 0);
+ f_fss_apply_delimit_range(delimits, range, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
const f_string_range_t range = f_string_range_t_initialize;
f_string_static_t empty = f_string_static_t_initialize;
- const f_status_t status = f_fss_apply_delimit_range(state_data, delimits, range, &empty);
+ f_fss_apply_delimit_range(delimits, range, &empty, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_apply_delimit_range(state_data, delimits, range, &test);
+ f_fss_apply_delimit_range(delimits, range, &test, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, test.used - 1);
f_string_static_t empty = f_string_static_t_initialize;
- const f_status_t status = f_fss_apply_delimit_range(state_data, delimits, range, &empty);
+ f_fss_apply_delimit_range(delimits, range, &empty, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, tests[i].used - 1);
- const f_status_t status = f_fss_apply_delimit_range(state_data, delimitss[i], range, &tests[i]);
+ f_fss_apply_delimit_range(delimitss[i], range, &tests[i], &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(tests[i].used, expects[i].used);
for (uint8_t j = 0; j < tests[i].used; ++j) {
f_state_t state_data = f_state_t_initialize;
{
- const f_status_t status = f_fss_count_lines(state_data, test, 0, 0);
+ f_fss_count_lines(test, 0, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
{
f_array_length_t line = 0;
- const f_status_t status = f_fss_count_lines(state_data, f_string_empty_s, 0, &line);
+ f_fss_count_lines(f_string_empty_s, 0, &line, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
for (uint8_t i = 0; i < 5; expect += ++i) {
- const f_status_t status = f_fss_count_lines(state_data, buffers[i], buffers[i].used, &line);
+ f_fss_count_lines(buffers[i], buffers[i].used, &line, &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(line, expect);
} // for
}
const f_string_range_t range = f_string_range_t_initialize;
{
- const f_status_t status = f_fss_count_lines_range(state_data, f_string_empty_s, range, 0);
+ f_fss_count_lines_range(f_string_empty_s, range, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
f_array_length_t line = 0;
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_count_lines_range(state_data, f_string_empty_s, range, &line);
+ f_fss_count_lines_range(f_string_empty_s, range, &line, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_array_length_t line = 0;
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_count_lines_range(state_data, test, range, &line);
+ f_fss_count_lines_range(test, range, &line, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_array_length_t line = 0;
f_string_range_t range = macro_f_string_range_t_initialize_1(0, test.used - 1);
- const f_status_t status = f_fss_count_lines_range(state_data, f_string_empty_s, range, &line);
+ f_fss_count_lines_range(f_string_empty_s, range, &line, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
f_string_range_t range = macro_f_string_range_t_initialize_1(0, buffers[i].used - 1);
- const f_status_t status = f_fss_count_lines_range(state_data, buffers[i], range, &line);
+ f_fss_count_lines_range(buffers[i], range, &line, &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(line, expect);
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf(state_data, F_status_set_error(i));
+ state_data.status = F_status_set_error(i);
+
+ f_fss_fail_utf(&state_data);
for (j = 0; j < 3; ++j) {
if (i == statuss[j]) break;
} // for
if (j == 3) {
- assert_int_equal(status, F_status_set_error(i));
+ assert_int_equal(state_data.status, F_status_set_error(i));
}
else {
- assert_int_equal(status, statuss[j]);
+ assert_int_equal(state_data.status, statuss[j]);
}
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf(state_data, F_status_set_error(i));
+ state_data.status = F_status_set_error(i);
+
+ f_fss_fail_utf(&state_data);
- assert_int_equal(status, F_status_set_error(i));
+ assert_int_equal(state_data.status, F_status_set_error(i));
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf(state_data, i);
+ state_data.status = i;
- assert_int_equal(status, i);
+ f_fss_fail_utf(&state_data);
+
+ assert_int_equal(state_data.status, i);
} // for
state_data.flag |= f_fss_state_flag_utf_fail_on_valid_not_e;
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf(state_data, i);
+ state_data.status = i;
+
+ f_fss_fail_utf(&state_data);
- assert_int_equal(status, i);
+ assert_int_equal(state_data.status, i);
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf_to_false(state_data, F_status_set_error(i));
+ state_data.status = F_status_set_error(i);
+
+ f_fss_fail_utf_to_false(&state_data);
for (j = 0; j < 3; ++j) {
if (i == statuss[j]) break;
} // for
if (j == 3) {
- assert_int_equal(status, F_status_set_error(i));
+ assert_int_equal(state_data.status, F_status_set_error(i));
}
else {
- assert_int_equal(status, F_false);
+ assert_int_equal(state_data.status, F_false);
}
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf_to_false(state_data, F_status_set_error(i));
+ state_data.status = F_status_set_error(i);
+
+ f_fss_fail_utf_to_false(&state_data);
- assert_int_equal(status, F_status_set_error(i));
+ assert_int_equal(state_data.status, F_status_set_error(i));
} // for
}
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf_to_false(state_data, i);
+ state_data.status = i;
- assert_int_equal(status, i);
+ f_fss_fail_utf_to_false(&state_data);
+
+ assert_int_equal(state_data.status, i);
} // for
state_data.flag |= f_fss_state_flag_utf_fail_on_valid_not_e;
for (f_status_t i = 0; i < F_status_code_last; ++i) {
- const f_status_t status = f_fss_fail_utf_to_false(state_data, i);
+ state_data.status = i;
+
+ f_fss_fail_utf_to_false(&state_data);
- assert_int_equal(status, i);
+ assert_int_equal(state_data.status, i);
} // for
}
const f_string_range_t range = macro_f_string_range_t_initialize_1(offset[i], tests[i].used - 1);
- const f_status_t status = f_fss_is_combining(state_data, tests[i], range);
+ const f_status_t status = f_fss_is_combining(tests[i], range, &state_data);
assert_int_equal(status, expects[i]);
} // for
{
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_combining(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_combining(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
{
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, 2);
- const f_status_t status = f_fss_is_combining(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_combining(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_combining(state_data, test, range);
+ const f_status_t status = f_fss_is_combining(test, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, tests[i].used - 1);
- const f_status_t status = f_fss_is_graph(state_data, tests[i], range);
+ const f_status_t status = f_fss_is_graph(tests[i], range, &state_data);
assert_int_equal(status, expects[i]);
} // for
{
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_graph(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_graph(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
{
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, 2);
- const f_status_t status = f_fss_is_graph(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_graph(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_graph(state_data, test, range);
+ const f_status_t status = f_fss_is_graph(test, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, tests[i].used - 1);
- const f_status_t status = f_fss_is_space(state_data, tests[i], range);
+ const f_status_t status = f_fss_is_space(tests[i], range, &state_data);
assert_int_equal(status, expects[i]);
} // for
{
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_space(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_space(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
{
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, 2);
- const f_status_t status = f_fss_is_space(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_space(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_space(state_data, test, range);
+ const f_status_t status = f_fss_is_space(test, range, &state_data);
assert_int_equal(status, F_false);
}
for (f_array_length_t i = 0; i < 14; ++i) {
- const f_status_t status = f_fss_is_zero_width(state_data, tests[i], ranges[i]);
+ const f_status_t status = f_fss_is_zero_width(tests[i], ranges[i], &state_data);
assert_int_equal(status, expects[i]);
} // for
{
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_zero_width(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_zero_width(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
{
const f_string_range_t range = macro_f_string_range_t_initialize_1(0, 2);
- const f_status_t status = f_fss_is_zero_width(state_data, f_string_empty_s, range);
+ const f_status_t status = f_fss_is_zero_width(f_string_empty_s, range, &state_data);
assert_int_equal(status, F_false);
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_is_zero_width(state_data, test, range);
+ const f_status_t status = f_fss_is_zero_width(test, range, &state_data);
assert_int_equal(status, F_false);
}
f_state_t state_data = f_state_t_initialize;
{
- const f_status_t status = f_fss_seek_to_eol(state_data, test, 0);
+ f_fss_seek_to_eol(test, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_seek_to_eol(state_data, f_string_empty_s, &range);
- assert_int_equal(status, F_data_not);
+ f_fss_seek_to_eol(f_string_empty_s, &range, &state_data);
+
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_seek_to_eol(state_data, test, &range);
- assert_int_equal(status, F_data_not);
+ f_fss_seek_to_eol(test, &range, &state_data);
+
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = macro_f_string_range_t_initialize_1(0, 1);
- const f_status_t status = f_fss_seek_to_eol(state_data, f_string_empty_s, &range);
- assert_int_equal(status, F_data_not);
+ f_fss_seek_to_eol(f_string_empty_s, &range, &state_data);
+
+ assert_int_equal(state_data.status, F_data_not);
}
}
f_string_range_t range = ranges[i];
- const f_status_t status = f_fss_seek_to_eol(state_data, tests[i], &range);
+ f_fss_seek_to_eol(tests[i], &range, &state_data);
- assert_int_equal(status, statuss[i]);
+ assert_int_equal(state_data.status, statuss[i]);
assert_int_equal(range.start, expects[i]);
} // for
}
f_state_t state_data = f_state_t_initialize;
{
- const f_status_t status = f_fss_skip_past_delimit(state_data, test, 0);
+ f_fss_skip_past_delimit(test, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_skip_past_delimit(state_data, f_string_empty_s, &range);
+ f_fss_skip_past_delimit(f_string_empty_s, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_skip_past_delimit(state_data, test, &range);
+ f_fss_skip_past_delimit(test, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = macro_f_string_range_t_initialize_1(0, test.used - 1);
- const f_status_t status = f_fss_skip_past_delimit(state_data, f_string_empty_s, &range);
+ f_fss_skip_past_delimit(f_string_empty_s, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = macro_f_string_range_t_initialize_1(test.used, test.used + 2);
- const f_status_t status = f_fss_skip_past_delimit(state_data, test, &range);
+ f_fss_skip_past_delimit(test, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
f_string_range_t range = macro_f_string_range_t_initialize_1(0, tests[i].used - 1);
- const f_status_t status = f_fss_skip_past_delimit(state_data, tests[i], &range);
+ f_fss_skip_past_delimit(tests[i], &range, &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(range.start, expects[i]);
} // for
}
f_state_t state_data = f_state_t_initialize;
{
- const f_status_t status = f_fss_skip_past_space(state_data, test, 0);
+ f_fss_skip_past_space(test, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_skip_past_space(state_data, f_string_empty_s, &range);
+ f_fss_skip_past_space(f_string_empty_s, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_fss_skip_past_space(state_data, test, &range);
+ f_fss_skip_past_space(test, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = macro_f_string_range_t_initialize_1(0, test.used - 1);
- const f_status_t status = f_fss_skip_past_space(state_data, f_string_empty_s, &range);
+ f_fss_skip_past_space(f_string_empty_s, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
{
f_string_range_t range = macro_f_string_range_t_initialize_1(test.used, test.used + 2);
- const f_status_t status = f_fss_skip_past_space(state_data, test, &range);
+ f_fss_skip_past_space(test, &range, &state_data);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(state_data.status, F_data_not);
}
}
f_string_range_t range = macro_f_string_range_t_initialize_1(0, tests[i].used - 1);
- const f_status_t status = f_fss_skip_past_space(state_data, tests[i], &range);
+ f_fss_skip_past_space(tests[i], &range, &state_data);
- assert_int_equal(status, F_none);
+ assert_int_equal(state_data.status, F_none);
assert_int_equal(range.start, expects[i]);
} // for
}
void test__f_iki_read__parameter_checking(void **state) {
- const f_state_t the_state = f_state_t_initialize;
+ f_state_t state_data = f_state_t_initialize;
f_string_static_t empty = macro_f_string_static_t_initialize_1(f_string_empty_s.string, f_string_empty_s.size, f_string_empty_s.used);
{
f_string_range_t range = f_string_range_t_initialize;
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, 0, &range, &iki);
+ f_iki_read(0, &range, &iki, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
{
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, &empty, 0, &iki);
+ f_iki_read(&empty, 0, &iki, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
{
f_string_range_t range = f_string_range_t_initialize;
- const f_status_t status = f_iki_read(the_state, &empty, &range, 0);
+ f_iki_read(&empty, &range, 0, &state_data);
- assert_int_equal(status, F_status_set_error(F_parameter));
+ assert_int_equal(state_data.status, F_status_set_error(F_parameter));
}
}
void test__f_iki_read__returns_data_not(void **state) {
- const f_state_t the_state = f_state_t_initialize;
+ f_state_t state_data = f_state_t_initialize;
f_string_static_t empty = macro_f_string_static_t_initialize_1(f_string_empty_s.string, f_string_empty_s.size, f_string_empty_s.used);
{
f_string_range_t range = f_string_range_t_initialize;
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, &empty, &range, &iki);
+ f_iki_read(&empty, &range, &iki, &state_data);
- assert_int_equal(F_status_set_fine(status), F_data_not);
+ assert_int_equal(F_status_set_fine(state_data.status), F_data_not);
}
}
void test__f_iki_read__returns_data_not_eos(void **state) {
- const f_state_t the_state = f_state_t_initialize;
+ f_state_t state_data = f_state_t_initialize;
f_string_static_t ascii_a = macro_f_string_static_t_initialize_1(f_string_ascii_a_s.string, f_string_ascii_a_s.size, f_string_ascii_a_s.used);
{
f_string_range_t range = macro_f_string_range_t_initialize_1(f_string_ascii_a_s.used, f_string_ascii_a_s.used);
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, &ascii_a, &range, &iki);
+ f_iki_read(&ascii_a, &range, &iki, &state_data);
- assert_int_equal(F_status_set_fine(status), F_data_not_eos);
+ assert_int_equal(F_status_set_fine(state_data.status), F_data_not_eos);
}
}
void test__f_iki_read__returns_data_not_stop(void **state) {
- const f_state_t the_state = f_state_t_initialize;
+ f_state_t state_data = f_state_t_initialize;
f_string_static_t ascii_a = macro_f_string_static_t_initialize_1(f_string_ascii_a_s.string, f_string_ascii_a_s.size, f_string_ascii_a_s.used);
{
f_string_range_t range = f_string_range_t_initialize;
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, &ascii_a, &range, &iki);
+ f_iki_read(&ascii_a, &range, &iki, &state_data);
- assert_int_equal(F_status_set_fine(status), F_data_not_stop);
+ assert_int_equal(F_status_set_fine(state_data.status), F_data_not_stop);
}
}
void test__f_iki_read__works(void **state) {
- const f_state_t the_state = f_state_t_initialize;
+ f_state_t state_data = f_state_t_initialize;
f_string_static_t empty = macro_f_string_static_t_initialize_1(f_string_empty_s.string, f_string_empty_s.size, f_string_empty_s.used);
f_string_static_t ascii_a = macro_f_string_static_t_initialize_1(f_string_ascii_a_s.string, f_string_ascii_a_s.size, f_string_ascii_a_s.used);
f_string_range_t range = macro_f_string_range_t_initialize_2(buffers[i].used);
f_iki_data_t iki = f_iki_data_t_initialize;
- const f_status_t status = f_iki_read(the_state, &buffers[i], &range, &iki);
+ f_iki_read(&buffers[i], &range, &iki, &state_data);
- assert_int_equal(status, statuss[i]);
+ assert_int_equal(state_data.status, statuss[i]);
if (matches[i] == 2) {
- const f_status_t status = f_iki_read(the_state, &buffers[i], &range, &iki);
+ f_iki_read(&buffers[i], &range, &iki, &state_data);
- assert_int_equal(F_status_is_error_not(status) ? 0 : 1, 0);
+ assert_int_equal(F_status_is_error_not(state_data.status) ? 0 : 1, 0);
}
assert_int_equal(iki.variable.used, matches[i]);
build_libraries -lc -lcmocka
build_libraries-individual -lf_memory -lf_string -lf_type_array -lf_utf -lf_pipe
-build_sources_program test-pipe-debug_exists.c test-pipe-error_exists.c test-pipe-input_exists.c test-pipe-warning_exists.c
+build_sources_program test-pipe-error_exists.c test-pipe-input_exists.c test-pipe-output_exists.c
build_sources_program test-pipe.c
build_script no
+++ /dev/null
-/**
- * FLL - Level 0
- *
- * Project: Pipe
- * API Version: 0.7
- * Licenses: lgpl-2.1-or-later
- *
- * Test the pipe project.
- */
-#ifndef _TEST__F_pipe_debug_exists_h
-#define _TEST__F_pipe_debug_exists_h
-
-/**
- * Test that function fails.
- *
- * @see f_pipe_debug_exists()
- */
-extern void test__f_pipe_debug_exists__fails(void **state);
-
-/**
- * Test that function returns F_false.
- *
- * @see f_pipe_debug_exists()
- */
-extern void test__f_pipe_debug_exists__returns_false(void **state);
-
-/**
- * Test that function returns F_true.
- *
- * @see f_pipe_debug_exists()
- */
-extern void test__f_pipe_debug_exists__returns_true(void **state);
-
-#endif // _TEST__F_pipe_debug_exists_h
#include "test-pipe.h"
-#include "test-pipe-debug_exists.h"
+#include "test-pipe-output_exists.h"
#ifdef __cplusplus
extern "C" {
#endif
-void test__f_pipe_debug_exists__fails(void **state) {
+void test__f_pipe_output_exists__fails(void **state) {
int errnos[] = {
EACCES,
will_return(__wrap_fstat, true);
will_return(__wrap_fstat, errnos[i]);
- const f_status_t status = f_pipe_debug_exists();
+ const f_status_t status = f_pipe_output_exists();
assert_int_equal(status, F_status_set_error(F_file_stat));
} // for
}
-void test__f_pipe_debug_exists__returns_false(void **state) {
+void test__f_pipe_output_exists__returns_false(void **state) {
struct stat statistics;
will_return(__wrap_fstat, &statistics);
will_return(__wrap_fstat, 0);
- const f_status_t status = f_pipe_debug_exists();
+ const f_status_t status = f_pipe_output_exists();
assert_int_equal(status, F_false);
}
}
-void test__f_pipe_debug_exists__returns_true(void **state) {
+void test__f_pipe_output_exists__returns_true(void **state) {
struct stat statistics;
will_return(__wrap_fstat, &statistics);
will_return(__wrap_fstat, 0);
- const f_status_t status = f_pipe_debug_exists();
+ const f_status_t status = f_pipe_output_exists();
assert_int_equal(status, F_true);
}
--- /dev/null
+/**
+ * FLL - Level 0
+ *
+ * Project: Pipe
+ * API Version: 0.7
+ * Licenses: lgpl-2.1-or-later
+ *
+ * Test the pipe project.
+ */
+#ifndef _TEST__F_pipe_output_exists_h
+#define _TEST__F_pipe_output_exists_h
+
+/**
+ * Test that function fails.
+ *
+ * @see f_pipe_output_exists()
+ */
+extern void test__f_pipe_output_exists__fails(void **state);
+
+/**
+ * Test that function returns F_false.
+ *
+ * @see f_pipe_output_exists()
+ */
+extern void test__f_pipe_output_exists__returns_false(void **state);
+
+/**
+ * Test that function returns F_true.
+ *
+ * @see f_pipe_output_exists()
+ */
+extern void test__f_pipe_output_exists__returns_true(void **state);
+
+#endif // _TEST__F_pipe_output_exists_h
+++ /dev/null
-#include "test-pipe.h"
-#include "test-pipe-warning_exists.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void test__f_pipe_warning_exists__fails(void **state) {
-
- int errnos[] = {
- EACCES,
- EBADF,
- EFAULT,
- EINVAL,
- ELOOP,
- ENAMETOOLONG,
- ENOENT,
- ENOMEM,
- ENOTDIR,
- EOVERFLOW,
- mock_errno_generic,
- };
-
- for (int i = 0; i < 11; ++i) {
-
- will_return(__wrap_fstat, true);
- will_return(__wrap_fstat, errnos[i]);
-
- const f_status_t status = f_pipe_warning_exists();
-
- assert_int_equal(status, F_status_set_error(F_file_stat));
- } // for
-}
-
-void test__f_pipe_warning_exists__returns_false(void **state) {
-
- struct stat statistics;
-
- memset(&statistics, 0, sizeof(struct stat));
-
- {
- statistics.st_mode = 1 | S_IFREG;
-
- will_return(__wrap_fstat, false);
- will_return(__wrap_fstat, &statistics);
- will_return(__wrap_fstat, 0);
-
- const f_status_t status = f_pipe_warning_exists();
-
- assert_int_equal(status, F_false);
- }
-}
-
-void test__f_pipe_warning_exists__returns_true(void **state) {
-
- struct stat statistics;
-
- memset(&statistics, 0, sizeof(struct stat));
-
- {
- statistics.st_mode = 1 | S_IFIFO;
-
- will_return(__wrap_fstat, false);
- will_return(__wrap_fstat, &statistics);
- will_return(__wrap_fstat, 0);
-
- const f_status_t status = f_pipe_warning_exists();
-
- assert_int_equal(status, F_true);
- }
-}
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
+++ /dev/null
-/**
- * FLL - Level 0
- *
- * Project: Pipe
- * API Version: 0.7
- * Licenses: lgpl-2.1-or-later
- *
- * Test the pipe project.
- */
-#ifndef _TEST__F_pipe_warning_exists_h
-#define _TEST__F_pipe_warning_exists_h
-
-/**
- * Test that function fails.
- *
- * @see f_pipe_warning_exists()
- */
-extern void test__f_pipe_warning_exists__fails(void **state);
-
-/**
- * Test that function returns F_false.
- *
- * @see f_pipe_warning_exists()
- */
-extern void test__f_pipe_warning_exists__returns_false(void **state);
-
-/**
- * Test that function returns F_true.
- *
- * @see f_pipe_warning_exists()
- */
-extern void test__f_pipe_warning_exists__returns_true(void **state);
-
-#endif // _TEST__F_pipe_warning_exists_h
int main(void) {
const struct CMUnitTest tests[] = {
- cmocka_unit_test(test__f_pipe_debug_exists__fails),
- cmocka_unit_test(test__f_pipe_debug_exists__returns_false),
- cmocka_unit_test(test__f_pipe_debug_exists__returns_true),
-
cmocka_unit_test(test__f_pipe_error_exists__fails),
cmocka_unit_test(test__f_pipe_error_exists__returns_false),
cmocka_unit_test(test__f_pipe_error_exists__returns_true),
cmocka_unit_test(test__f_pipe_input_exists__returns_false),
cmocka_unit_test(test__f_pipe_input_exists__returns_true),
- cmocka_unit_test(test__f_pipe_warning_exists__fails),
- cmocka_unit_test(test__f_pipe_warning_exists__returns_false),
- cmocka_unit_test(test__f_pipe_warning_exists__returns_true),
+ cmocka_unit_test(test__f_pipe_output_exists__fails),
+ cmocka_unit_test(test__f_pipe_output_exists__returns_false),
+ cmocka_unit_test(test__f_pipe_output_exists__returns_true),
#ifndef _di_level_0_parameter_checking_
- // f_pipe_debug_exists() doesn't use parameter checking.
// f_pipe_error_exists() doesn't use parameter checking.
// f_pipe_input_exists() doesn't use parameter checking.
- // f_pipe_warning_exists() doesn't use parameter checking.
+ // f_pipe_output_exists() doesn't use parameter checking.
#endif // _di_level_0_parameter_checking_
};
#include "mock-pipe.h"
// Test includes.
-#include "test-pipe-debug_exists.h"
#include "test-pipe-error_exists.h"
#include "test-pipe-input_exists.h"
-#include "test-pipe-warning_exists.h"
+#include "test-pipe-output_exists.h"
#ifdef __cplusplus
extern "C" {
void test__f_print__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print(test.string, test.used, stdout);
+ const f_status_t status = f_print(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print__parameter_checking(void **state) {
+void test__f_print__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print(test.string, test.used, 0);
+ const f_status_t status = f_print(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print(f_string_empty_s.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print(test.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print(0, test.used, stdout);
+ const f_status_t status = f_print(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print(test.string, test.used, stdout);
+ const f_status_t status = f_print(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print()
*/
-extern void test__f_print__parameter_checking(void **state);
+extern void test__f_print__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print()
*/
-extern void test__f_print__returns_data_not(void **state);
+extern void test__f_print__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_character__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character(test.string[0], stdout);
+ const f_status_t status = f_print_character(test.string[0], output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_character__parameter_checking(void **state) {
+void test__f_print_character__returns_stream_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_character(test.string[0], 0);
+ const f_status_t status = f_print_character(test.string[0], output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_character__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_character(test.string[0], stdout);
+ const f_status_t status = f_print_character(test.string[0], output);
assert_int_equal(status, F_none);
}
extern void test__f_print_character__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_character()
*/
-extern void test__f_print_character__parameter_checking(void **state);
+extern void test__f_print_character__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_character_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character_safely(test.string[0], stdout);
+ const f_status_t status = f_print_character_safely(test.string[0], output);
assert_int_equal(status, F_status_set_error(F_output));
}
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character_safely((f_char_t) 0x7f, stdout);
+ const f_status_t status = f_print_character_safely((f_char_t) 0x7f, output);
assert_int_equal(status, F_status_set_error(F_output));
}
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character_safely((f_char_t) F_utf_byte_1_d, stdout);
+ const f_status_t status = f_print_character_safely((f_char_t) F_utf_byte_1_d, output);
assert_int_equal(status, F_status_set_error(F_output));
}
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character_safely(alternate.string[0], stdout);
+ const f_status_t status = f_print_character_safely(alternate.string[0], output);
assert_int_equal(status, F_status_set_error(F_output));
}
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_character_safely(test.string[0], stdout);
+ const f_status_t status = f_print_character_safely(test.string[0], output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_character_safely__parameter_checking(void **state) {
+void test__f_print_character_safely__returns_stream_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_character_safely(test.string[0], 0);
+ const f_status_t status = f_print_character_safely(test.string[0], output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_character_safely__returns_utf(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("è ‡", 0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_character_safely(test.string[0], stdout);
+ const f_status_t status = f_print_character_safely(test.string[0], output);
assert_int_equal(status, F_utf);
}
void test__f_print_character_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, f_print_sequence_delete_s.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_character_safely((f_char_t) 0x7f, stdout);
+ const f_status_t status = f_print_character_safely((f_char_t) 0x7f, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, f_print_sequence_unknown_s.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_character_safely((f_char_t) F_utf_byte_1_d, stdout);
+ const f_status_t status = f_print_character_safely((f_char_t) F_utf_byte_1_d, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_character_safely(test.string[0], stdout);
+ const f_status_t status = f_print_character_safely(test.string[0], output);
assert_int_equal(status, F_none);
}
extern void test__f_print_character_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_character_safely()
*/
-extern void test__f_print_character_safely__parameter_checking(void **state);
+extern void test__f_print_character_safely__returns_stream_not(void **state);
/**
* Test that function works but returns F_utf.
void test__f_print_dynamic__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic(test, stdout);
+ const f_status_t status = f_print_dynamic(test, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic__parameter_checking(void **state) {
+void test__f_print_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic(test, 0);
+ const f_status_t status = f_print_dynamic(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic__returns_data_not(void **state) {
+void test__f_print_dynamic__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic(f_string_empty_s, stdout);
+ const f_status_t status = f_print_dynamic(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic(test, stdout);
+ const f_status_t status = f_print_dynamic(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic()
*/
-extern void test__f_print_dynamic__parameter_checking(void **state);
+extern void test__f_print_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic()
*/
-extern void test__f_print_dynamic__returns_data_not(void **state);
+extern void test__f_print_dynamic__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_partial(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial(test, partial, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial(test, partial, 0);
+ const f_status_t status = f_print_dynamic_partial(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_dynamic_partial__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial(f_string_empty_s, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_partial(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_partial()
*/
-extern void test__f_print_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_partial()
*/
-extern void test__f_print_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_dynamic_partial__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_partial_raw(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw(test, partial, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_raw(test, partial, 0);
+ const f_status_t status = f_print_dynamic_partial_raw(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_dynamic_partial_raw__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_raw(f_string_empty_s, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, 3);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_partial_raw(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_partial_raw()
*/
-extern void test__f_print_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_partial_raw()
*/
-extern void test__f_print_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_dynamic_partial_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, 0);
+ const f_status_t status = f_print_dynamic_partial_raw_safely(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_dynamic_partial_raw_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_raw_safely(f_string_empty_s, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, 3);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_raw_safely(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_partial_raw_safely()
*/
-extern void test__f_print_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_partial_raw_safely()
*/
-extern void test__f_print_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_dynamic_partial_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_partial_safely(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_safely(test, partial, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_safely(test, partial, 0);
+ const f_status_t status = f_print_dynamic_partial_safely(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_dynamic_partial_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_partial_safely(f_string_empty_s, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_safely(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, 3);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_partial_safely(test, partial, stdout);
+ const f_status_t status = f_print_dynamic_partial_safely(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_partial_safely()
*/
-extern void test__f_print_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_partial_safely()
*/
-extern void test__f_print_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_dynamic_partial_safely__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_dynamic_raw__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_raw(test, stdout);
+ const f_status_t status = f_print_dynamic_raw(test, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_raw(test, 0);
+ const f_status_t status = f_print_dynamic_raw(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_dynamic_raw__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_raw(f_string_empty_s, stdout);
+ const f_status_t status = f_print_dynamic_raw(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_raw(test, stdout);
+ const f_status_t status = f_print_dynamic_raw(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_raw()
*/
-extern void test__f_print_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_raw()
*/
-extern void test__f_print_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_dynamic_raw__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_dynamic_raw_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_raw_safely(test, stdout);
+ const f_status_t status = f_print_dynamic_raw_safely(test, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_raw_safely(test, 0);
+ const f_status_t status = f_print_dynamic_raw_safely(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_dynamic_raw_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_raw_safely(f_string_empty_s, stdout);
+ const f_status_t status = f_print_dynamic_raw_safely(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_raw_safely(test, stdout);
+ const f_status_t status = f_print_dynamic_raw_safely(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_raw_safely()
*/
-extern void test__f_print_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_raw_safely()
*/
-extern void test__f_print_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_dynamic_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_dynamic_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_dynamic_safely(test, stdout);
+ const f_status_t status = f_print_dynamic_safely(test, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_safely(test, 0);
+ const f_status_t status = f_print_dynamic_safely(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_dynamic_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_dynamic_safely(f_string_empty_s, stdout);
+ const f_status_t status = f_print_dynamic_safely(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_dynamic_safely(test, stdout);
+ const f_status_t status = f_print_dynamic_safely(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_dynamic_safely()
*/
-extern void test__f_print_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_dynamic_safely()
*/
-extern void test__f_print_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_dynamic_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except__parameter_checking(void **state) {
+void test__f_print_except__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_except(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_except(f_string_empty_s.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except(test.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except(0, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except(test.string, 2, test.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except(test.string, 1, test.used, except, stdout);
+ const f_status_t status = f_print_except(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except()
*/
-extern void test__f_print_except__parameter_checking(void **state);
+extern void test__f_print_except__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except()
*/
-extern void test__f_print_except__returns_data_not(void **state);
+extern void test__f_print_except__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic(test, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic__parameter_checking(void **state) {
+void test__f_print_except_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic(test, except, 0);
+ const f_status_t status = f_print_except_dynamic(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic__returns_data_not(void **state) {
+void test__f_print_except_dynamic__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic(f_string_empty_s, except, stdout);
+ const f_status_t status = f_print_except_dynamic(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic()
*/
-extern void test__f_print_except_dynamic__parameter_checking(void **state);
+extern void test__f_print_except_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic()
*/
-extern void test__f_print_except_dynamic__returns_data_not(void **state);
+extern void test__f_print_except_dynamic__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_partial(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_except_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial(test, partial, except, 0);
+ const f_status_t status = f_print_except_dynamic_partial(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_except_dynamic_partial__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial(f_string_empty_s, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_partial()
*/
-extern void test__f_print_except_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_partial()
*/
-extern void test__f_print_except_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_partial__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_except_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, 0);
+ const f_status_t status = f_print_except_dynamic_partial_raw(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_except_dynamic_partial_raw__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_raw(f_string_empty_s, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_partial_raw()
*/
-extern void test__f_print_except_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_partial_raw()
*/
-extern void test__f_print_except_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_partial_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, 0);
+ const f_status_t status = f_print_except_dynamic_partial_raw_safely(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_except_dynamic_partial_raw_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_raw_safely(f_string_empty_s, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_partial_raw_safely()
*/
-extern void test__f_print_except_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_partial_raw_safely()
*/
-extern void test__f_print_except_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_partial_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_except_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, 0);
+ const f_status_t status = f_print_except_dynamic_partial_safely(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_except_dynamic_partial_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_partial_safely(f_string_empty_s, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, stdout);
+ const f_status_t status = f_print_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_partial_safely()
*/
-extern void test__f_print_except_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_partial_safely()
*/
-extern void test__f_print_except_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_partial_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_raw(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_except_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_raw(test, except, 0);
+ const f_status_t status = f_print_except_dynamic_raw(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_except_dynamic_raw__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_raw(f_string_empty_s, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_raw(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_raw(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_raw()
*/
-extern void test__f_print_except_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_raw()
*/
-extern void test__f_print_except_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_raw_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_raw_safely(test, except, 0);
+ const f_status_t status = f_print_except_dynamic_raw_safely(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_except_dynamic_raw_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_raw_safely(f_string_empty_s, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw_safely(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_raw_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_raw_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_raw_safely()
*/
-extern void test__f_print_except_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_raw_safely()
*/
-extern void test__f_print_except_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_dynamic_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_except_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_safely(test, except, 0);
+ const f_status_t status = f_print_except_dynamic_safely(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_except_dynamic_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_dynamic_safely(f_string_empty_s, except, stdout);
+ const f_status_t status = f_print_except_dynamic_safely(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_dynamic_safely(test, except, stdout);
+ const f_status_t status = f_print_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_dynamic_safely()
*/
-extern void test__f_print_except_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_except_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_dynamic_safely()
*/
-extern void test__f_print_except_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_except_dynamic_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in__parameter_checking(void **state) {
+void test__f_print_except_in__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_except_in(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_in__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_except_in(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_in(test.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_in__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in(0, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(F_status_set_fine(status), F_stream_not);
}
}
void test__f_print_except_in__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in(test.string, 2, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in(test.string, 1, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in()
*/
-extern void test__f_print_except_in__parameter_checking(void **state);
+extern void test__f_print_except_in__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in()
*/
-extern void test__f_print_except_in__returns_data_not(void **state);
+extern void test__f_print_except_in__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic(test, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic(f_string_empty_s, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic()
*/
-extern void test__f_print_except_in_dynamic__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic()
*/
-extern void test__f_print_except_in_dynamic__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic__returns_stream_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_partial(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_partial__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial(f_string_empty_s, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_partial()
*/
-extern void test__f_print_except_in_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_partial()
*/
-extern void test__f_print_except_in_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_partial__returns_stream_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_partial_raw__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_raw(f_string_empty_s, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_partial_raw()
*/
-extern void test__f_print_except_in_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_partial_raw()
*/
-extern void test__f_print_except_in_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_partial_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_partial_raw_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(f_string_empty_s, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_partial_raw_safely()
*/
-extern void test__f_print_except_in_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_partial_raw_safely()
*/
-extern void test__f_print_except_in_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_partial_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_partial_safely(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_partial_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_partial_safely(f_string_empty_s, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_partial_safely()
*/
-extern void test__f_print_except_in_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_partial_safely()
*/
-extern void test__f_print_except_in_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_partial_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_raw(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_raw__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_raw(f_string_empty_s, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_raw()
*/
-extern void test__f_print_except_in_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_raw()
*/
-extern void test__f_print_except_in_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_raw_safely(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_raw_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_raw_safely(f_string_empty_s, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_raw_safely()
*/
-extern void test__f_print_except_in_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_raw_safely()
*/
-extern void test__f_print_except_in_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_except_in_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, 0);
+ const f_status_t status = f_print_except_in_dynamic_safely(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_except_in_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_except_in_dynamic_safely__returns_stream_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_dynamic_safely(f_string_empty_s, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, stdout);
+ const f_status_t status = f_print_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_dynamic_safely()
*/
-extern void test__f_print_except_in_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_dynamic_safely()
*/
-extern void test__f_print_except_in_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_dynamic_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_raw__parameter_checking(void **state) {
+void test__f_print_except_in_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_except_in_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_in_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_except_in_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_in_raw(test.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_in_raw__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_raw(0, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw(test.string, 2, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw(test.string, 1, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_raw()
*/
-extern void test__f_print_except_in_raw__parameter_checking(void **state);
+extern void test__f_print_except_in_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_raw()
*/
-extern void test__f_print_except_in_raw__returns_data_not(void **state);
+extern void test__f_print_except_in_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_in_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_except_in_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_in_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_except_in_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_in_raw_safely(test.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_in_raw_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_raw_safely(0, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw_safely(test.string, 2, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_raw_safely(test.string, 1, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_raw_safely(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_raw_safely()
*/
-extern void test__f_print_except_in_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_raw_safely()
*/
-extern void test__f_print_except_in_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_in_safely__parameter_checking(void **state) {
+void test__f_print_except_in_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_except_in_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_in_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_except_in_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_in_safely(test.string, 0, f_string_empty_s.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_in_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_in_safely(0, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_in_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_safely(test.string, 2, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_in_safely(test.string, 1, test.used, except, range, stdout);
+ const f_status_t status = f_print_except_in_safely(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_in_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_in_safely()
*/
-extern void test__f_print_except_in_safely__parameter_checking(void **state);
+extern void test__f_print_except_in_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_in_safely()
*/
-extern void test__f_print_except_in_safely__returns_data_not(void **state);
+extern void test__f_print_except_in_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_raw__parameter_checking(void **state) {
+void test__f_print_except_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_except_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_except_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_raw(test.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_raw(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_raw__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_raw(0, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw(test.string, 2, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw(test.string, 1, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_raw()
*/
-extern void test__f_print_except_raw__parameter_checking(void **state);
+extern void test__f_print_except_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_raw()
*/
-extern void test__f_print_except_raw__returns_data_not(void **state);
+extern void test__f_print_except_raw__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_raw_safely__parameter_checking(void **state) {
+void test__f_print_except_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_except_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_except_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_raw_safely(test.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_raw_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_raw_safely(0, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw_safely(test.string, 2, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_raw_safely(test.string, 1, test.used, except, stdout);
+ const f_status_t status = f_print_except_raw_safely(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_raw_safely()
*/
-extern void test__f_print_except_raw_safely__parameter_checking(void **state);
+extern void test__f_print_except_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_raw_safely()
*/
-extern void test__f_print_except_raw_safely__returns_data_not(void **state);
+extern void test__f_print_except_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_except_safely__parameter_checking(void **state) {
+void test__f_print_except_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_except_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_except_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_except_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_except_safely(test.string, 0, f_string_empty_s.used, except, stdout);
+ const f_status_t status = f_print_except_safely(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_except_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_except_safely(0, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_except_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_safely(test.string, 2, test.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_fwrite_unlocked, test.used - 1);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_except_safely(test.string, 1, test.used, except, stdout);
+ const f_status_t status = f_print_except_safely(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_except_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_except_safely()
*/
-extern void test__f_print_except_safely__parameter_checking(void **state);
+extern void test__f_print_except_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_except_safely()
*/
-extern void test__f_print_except_safely__returns_data_not(void **state);
+extern void test__f_print_except_safely__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_raw__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_raw(test.string, test.used, stdout);
+ const f_status_t status = f_print_raw(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_raw__parameter_checking(void **state) {
+void test__f_print_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw(test.string, test.used, 0);
+ const f_status_t status = f_print_raw(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_raw(f_string_empty_s.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_raw(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_raw(test.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_raw(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_raw__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw(0, test.used, stdout);
+ const f_status_t status = f_print_raw(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_raw(test.string, test.used, stdout);
+ const f_status_t status = f_print_raw(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_raw()
*/
-extern void test__f_print_raw__parameter_checking(void **state);
+extern void test__f_print_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_raw()
*/
-extern void test__f_print_raw__returns_data_not(void **state);
+extern void test__f_print_raw__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_raw_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_raw_safely(test.string, test.used, stdout);
+ const f_status_t status = f_print_raw_safely(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_raw_safely__parameter_checking(void **state) {
+void test__f_print_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_raw_safely(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_raw_safely(f_string_empty_s.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_raw_safely(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_raw_safely(test.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_raw_safely(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_raw_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw_safely(0, test.used, stdout);
+ const f_status_t status = f_print_raw_safely(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_raw_safely(test.string, test.used, stdout);
+ const f_status_t status = f_print_raw_safely(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_raw_safely()
*/
-extern void test__f_print_raw_safely__parameter_checking(void **state);
+extern void test__f_print_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_raw_safely()
*/
-extern void test__f_print_raw_safely__returns_data_not(void **state);
+extern void test__f_print_raw_safely__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_raw_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_raw_terminated(test.string, stdout);
+ const f_status_t status = f_print_raw_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_raw_terminated__parameter_checking(void **state) {
+void test__f_print_raw_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw_terminated(test.string, 0);
+ const f_status_t status = f_print_raw_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_raw_terminated__returns_data_not(void **state) {
+void test__f_print_raw_terminated__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_raw_terminated(0, stdout);
+ const f_status_t status = f_print_raw_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_raw_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_raw_terminated(test.string, stdout);
+ const f_status_t status = f_print_raw_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_raw_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_raw_terminated()
*/
-extern void test__f_print_raw_terminated__parameter_checking(void **state);
+extern void test__f_print_raw_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_raw_terminated()
*/
-extern void test__f_print_raw_terminated__returns_data_not(void **state);
+extern void test__f_print_raw_terminated__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_safely(test.string, test.used, stdout);
+ const f_status_t status = f_print_safely(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_safely__parameter_checking(void **state) {
+void test__f_print_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_safely(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_safely(f_string_empty_s.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_safely(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_safely(test.string, f_string_empty_s.used, stdout);
+ const f_status_t status = f_print_safely(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_safely__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_safely(0, test.used, stdout);
+ const f_status_t status = f_print_safely(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_safely(test.string, test.used, stdout);
+ const f_status_t status = f_print_safely(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_safely()
*/
-extern void test__f_print_safely__parameter_checking(void **state);
+extern void test__f_print_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_safely()
*/
-extern void test__f_print_safely__returns_data_not(void **state);
+extern void test__f_print_safely__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_safely_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_safely_terminated(test.string, stdout);
+ const f_status_t status = f_print_safely_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_safely_terminated__parameter_checking(void **state) {
+void test__f_print_safely_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_safely_terminated(test.string, 0);
+ const f_status_t status = f_print_safely_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_safely_terminated__returns_data_not(void **state) {
+void test__f_print_safely_terminated__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_safely_terminated(0, stdout);
+ const f_status_t status = f_print_safely_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_safely_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_safely_terminated(test.string, stdout);
+ const f_status_t status = f_print_safely_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_safely_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_safely_terminated()
*/
-extern void test__f_print_safely_terminated__parameter_checking(void **state);
+extern void test__f_print_safely_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_safely_terminated()
*/
-extern void test__f_print_safely_terminated__returns_data_not(void **state);
+extern void test__f_print_safely_terminated__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, true);
will_return(__wrap_fwrite_unlocked, 0);
will_return(__wrap_ferror_unlocked, true);
- const f_status_t status = f_print_terminated(test.string, stdout);
+ const f_status_t status = f_print_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(F_output));
}
}
-void test__f_print_terminated__parameter_checking(void **state) {
+void test__f_print_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_terminated(test.string, 0);
+ const f_status_t status = f_print_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_terminated__returns_data_not(void **state) {
+void test__f_print_terminated__returns_stream_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_terminated(0, stdout);
+ const f_status_t status = f_print_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_stream_not);
}
}
void test__f_print_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_fwrite_unlocked, false);
will_return(__wrap_fwrite_unlocked, test.used);
will_return(__wrap_ferror_unlocked, false);
- const f_status_t status = f_print_terminated(test.string, stdout);
+ const f_status_t status = f_print_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_terminated()
*/
-extern void test__f_print_terminated__parameter_checking(void **state);
+extern void test__f_print_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_stream_not.
*
* @see f_print_terminated()
*/
-extern void test__f_print_terminated__returns_data_not(void **state);
+extern void test__f_print_terminated__returns_stream_not(void **state);
/**
* Test that function works.
void test__f_print_to__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to(test.string, test.used, 0);
+ const f_status_t status = f_print_to(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to__parameter_checking(void **state) {
+void test__f_print_to__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to(test.string, test.used, -1);
+ const f_status_t status = f_print_to(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_to(f_string_empty_s.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to(test.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to(0, test.used, 0);
+ const f_status_t status = f_print_to(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to(test.string, test.used, 0);
+ const f_status_t status = f_print_to(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to()
*/
-extern void test__f_print_to__parameter_checking(void **state);
+extern void test__f_print_to__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to()
*/
-extern void test__f_print_to__returns_data_not(void **state);
+extern void test__f_print_to__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_character__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character(test.string[0], 0);
+ const f_status_t status = f_print_to_character(test.string[0], output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_character__parameter_checking(void **state) {
+void test__f_print_to_character__returns_file_descriptor_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_character(test.string[0], -1);
+ const f_status_t status = f_print_to_character(test.string[0], output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_character__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, 1);
- const f_status_t status = f_print_to_character(test.string[0], 0);
+ const f_status_t status = f_print_to_character(test.string[0], output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_character__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_character()
*/
-extern void test__f_print_to_character__parameter_checking(void **state);
+extern void test__f_print_to_character__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_character_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character_safely(test.string[0], 0);
+ const f_status_t status = f_print_to_character_safely(test.string[0], output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character_safely((f_char_t) 0x7f, 0);
+ const f_status_t status = f_print_to_character_safely((f_char_t) 0x7f, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character_safely((f_char_t) F_utf_byte_1_d, 0);
+ const f_status_t status = f_print_to_character_safely((f_char_t) F_utf_byte_1_d, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character_safely(alternate.string[0], 0);
+ const f_status_t status = f_print_to_character_safely(alternate.string[0], output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_character_safely(test.string[0], 0);;
+ const f_status_t status = f_print_to_character_safely(test.string[0], output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_character_safely__parameter_checking(void **state) {
+void test__f_print_to_character_safely__returns_file_descriptor_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_character_safely(test.string[0], -1);
+ const f_status_t status = f_print_to_character_safely(test.string[0], output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_character_safely__returns_utf(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("è ‡", 0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, 1);
- const f_status_t status = f_print_to_character_safely(test.string[0], 0);
+ const f_status_t status = f_print_to_character_safely(test.string[0], output);
assert_int_equal(status, F_utf);
}
void test__f_print_to_character_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, f_print_sequence_delete_s.used);
- const f_status_t status = f_print_to_character_safely((f_char_t) 0x7f, 0);
+ const f_status_t status = f_print_to_character_safely((f_char_t) 0x7f, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, f_print_sequence_unknown_s.used);
- const f_status_t status = f_print_to_character_safely((f_char_t) F_utf_byte_1_d, 0);
+ const f_status_t status = f_print_to_character_safely((f_char_t) F_utf_byte_1_d, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, 1);
- const f_status_t status = f_print_to_character_safely(test.string[0], 0);
+ const f_status_t status = f_print_to_character_safely(test.string[0], output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_character_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_character_safely()
*/
-extern void test__f_print_to_character_safely__parameter_checking(void **state);
+extern void test__f_print_to_character_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works but returns F_utf.
void test__f_print_to_dynamic__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic(test, 0);
+ const f_status_t status = f_print_to_dynamic(test, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic__parameter_checking(void **state) {
+void test__f_print_to_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic(test, -1);
+ const f_status_t status = f_print_to_dynamic(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic__returns_data_not(void **state) {
+void test__f_print_to_dynamic__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic(f_string_empty_s, 0);
+ const f_status_t status = f_print_to_dynamic(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic(test, 0);
+ const f_status_t status = f_print_to_dynamic(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic()
*/
-extern void test__f_print_to_dynamic__parameter_checking(void **state);
+extern void test__f_print_to_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic()
*/
-extern void test__f_print_to_dynamic__returns_data_not(void **state);
+extern void test__f_print_to_dynamic__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_partial(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial(test, partial, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_to_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial(test, partial, -1);
+ const f_status_t status = f_print_to_dynamic_partial(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_to_dynamic_partial__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial(f_string_empty_s, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_partial(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_partial()
*/
-extern void test__f_print_to_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_partial()
*/
-extern void test__f_print_to_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_partial__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_to_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, -1);
+ const f_status_t status = f_print_to_dynamic_partial_raw(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_to_dynamic_partial_raw__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_raw(f_string_empty_s, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_partial_raw()
*/
-extern void test__f_print_to_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_partial_raw()
*/
-extern void test__f_print_to_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_partial_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, -1);
+ const f_status_t status = f_print_to_dynamic_partial_raw_safely(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_raw_safely(f_string_empty_s, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_raw_safely(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_to_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, -1);
+ const f_status_t status = f_print_to_dynamic_partial_safely(f_string_empty_s, partial, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_to_dynamic_partial_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_partial_safely(f_string_empty_s, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, 0);
+ const f_status_t status = f_print_to_dynamic_partial_safely(test, partial, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_partial_safely()
*/
-extern void test__f_print_to_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_partial_safely()
*/
-extern void test__f_print_to_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_partial_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_dynamic_raw__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_raw(test, 0);
+ const f_status_t status = f_print_to_dynamic_raw(test, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_to_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_raw(test, -1);
+ const f_status_t status = f_print_to_dynamic_raw(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_to_dynamic_raw__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_raw(f_string_empty_s, 0);
+ const f_status_t status = f_print_to_dynamic_raw(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_raw(test, 0);
+ const f_status_t status = f_print_to_dynamic_raw(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_raw()
*/
-extern void test__f_print_to_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_raw()
*/
-extern void test__f_print_to_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_dynamic_raw_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_raw_safely(test, 0);
+ const f_status_t status = f_print_to_dynamic_raw_safely(test, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_raw_safely(test, -1);
+ const f_status_t status = f_print_to_dynamic_raw_safely(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_dynamic_raw_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_raw_safely(f_string_empty_s, 0);
+ const f_status_t status = f_print_to_dynamic_raw_safely(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_raw_safely(test, 0);
+ const f_status_t status = f_print_to_dynamic_raw_safely(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_raw_safely()
*/
-extern void test__f_print_to_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_raw_safely()
*/
-extern void test__f_print_to_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_dynamic_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_dynamic_safely(test, 0);
+ const f_status_t status = f_print_to_dynamic_safely(test, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_to_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_safely(test, -1);
+ const f_status_t status = f_print_to_dynamic_safely(f_string_empty_s, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_to_dynamic_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_dynamic_safely(f_string_empty_s, 0);
+ const f_status_t status = f_print_to_dynamic_safely(test, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_dynamic_safely(test, 0);
+ const f_status_t status = f_print_to_dynamic_safely(test, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_dynamic_safely()
*/
-extern void test__f_print_to_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_to_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_dynamic_safely()
*/
-extern void test__f_print_to_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_to_dynamic_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except__parameter_checking(void **state) {
+void test__f_print_to_except__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except(test.string, 0, test.used, except, -1);
+ const f_status_t status = f_print_to_except(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_to_except(f_string_empty_s.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except(test.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except(0, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except(test.string, 2, test.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except(test.string, 1, test.used, except, 0);
+ const f_status_t status = f_print_to_except(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except()
*/
-extern void test__f_print_to_except__parameter_checking(void **state);
+extern void test__f_print_to_except__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except()
*/
-extern void test__f_print_to_except__returns_data_not(void **state);
+extern void test__f_print_to_except__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic(test, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic(test, except, -1);
+ const f_status_t status = f_print_to_except_dynamic(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic(f_string_empty_s, except, 0);
+ const f_status_t status = f_print_to_except_dynamic(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic()
*/
-extern void test__f_print_to_except_dynamic__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic()
*/
-extern void test__f_print_to_except_dynamic__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_partial(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_partial__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial(f_string_empty_s, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_partial()
*/
-extern void test__f_print_to_except_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_partial()
*/
-extern void test__f_print_to_except_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_partial__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_partial_raw__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_raw(f_string_empty_s, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_partial_raw()
*/
-extern void test__f_print_to_except_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_partial_raw()
*/
-extern void test__f_print_to_except_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_partial_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(f_string_empty_s, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_raw_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_except_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_except_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_partial_safely(f_string_empty_s, partial, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_partial_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_partial_safely(f_string_empty_s, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_partial_safely(test, partial, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_partial_safely()
*/
-extern void test__f_print_to_except_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_partial_safely()
*/
-extern void test__f_print_to_except_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_partial_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_raw(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_raw(test, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_raw(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_raw__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_raw(f_string_empty_s, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_raw(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_raw(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_raw()
*/
-extern void test__f_print_to_except_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_raw()
*/
-extern void test__f_print_to_except_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_raw_safely(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_raw_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_raw_safely(f_string_empty_s, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_raw_safely(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_raw_safely()
*/
-extern void test__f_print_to_except_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_raw_safely()
*/
-extern void test__f_print_to_except_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_dynamic_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_to_except_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_safely(test, except, -1);
+ const f_status_t status = f_print_to_except_dynamic_safely(f_string_empty_s, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_to_except_dynamic_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_dynamic_safely(f_string_empty_s, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_safely(test, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_dynamic_safely(test, except, 0);
+ const f_status_t status = f_print_to_except_dynamic_safely(test, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_dynamic_safely()
*/
-extern void test__f_print_to_except_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_dynamic_safely()
*/
-extern void test__f_print_to_except_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_dynamic_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in__parameter_checking(void **state) {
+void test__f_print_to_except_in__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, -1);
+ const f_status_t status = f_print_to_except_in(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_in__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_to_except_in(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_in(test.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_in__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in(0, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in(test.string, 2, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in(test.string, 1, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in()
*/
-extern void test__f_print_to_except_in__parameter_checking(void **state);
+extern void test__f_print_to_except_in__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in()
*/
-extern void test__f_print_to_except_in__returns_data_not(void **state);
+extern void test__f_print_to_except_in__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic(test, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic(f_string_empty_s, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_dynamic__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic()
*/
-extern void test__f_print_to_except_in_dynamic__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic()
*/
-extern void test__f_print_to_except_in_dynamic__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_partial__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_partial__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_partial(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_partial__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_partial__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial(f_string_empty_s, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_partial__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_partial()
*/
-extern void test__f_print_to_except_in_dynamic_partial__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_partial__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_partial()
*/
-extern void test__f_print_to_except_in_dynamic_partial__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_partial__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_partial_raw__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_partial_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_partial_raw__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_partial_raw__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw(f_string_empty_s, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_partial_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_partial_raw()
*/
-extern void test__f_print_to_except_in_dynamic_partial_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_partial_raw()
*/
-extern void test__f_print_to_except_in_dynamic_partial_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_partial_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(f_string_empty_s, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
};
const f_array_lengths_t except = macro_f_array_lengths_t_initialize_1(lengths, 0, 1);
const f_string_ranges_t range = macro_f_string_ranges_t_initialize_1(ranges, 0, 1);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_raw_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_partial_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_except_in_dynamic_partial_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_partial_raw_safely()
*/
-extern void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_partial_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_partial_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_safely(f_string_empty_s, partial, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_partial_safely__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_partial_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_partial_safely(f_string_empty_s, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_string_range_t partial = macro_f_string_range_t_initialize_1(0, 2);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_partial_safely(test, partial, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_partial_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_partial_safely()
*/
-extern void test__f_print_to_except_in_dynamic_partial_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_partial_safely()
*/
-extern void test__f_print_to_except_in_dynamic_partial_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_partial_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_raw__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_raw__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_raw(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_raw__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_raw__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_raw(f_string_empty_s, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_dynamic_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_raw()
*/
-extern void test__f_print_to_except_in_dynamic_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_raw()
*/
-extern void test__f_print_to_except_in_dynamic_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_raw_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_raw_safely(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_raw_safely__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_raw_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_raw_safely(f_string_empty_s, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_dynamic_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_raw_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_raw_safely()
*/
-extern void test__f_print_to_except_in_dynamic_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_raw_safely()
*/
-extern void test__f_print_to_except_in_dynamic_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_dynamic_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_dynamic_safely__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, -1);
+ const f_status_t status = f_print_to_except_in_dynamic_safely(f_string_empty_s, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_except_in_dynamic_safely__returns_data_not(void **state) {
+void test__f_print_to_except_in_dynamic_safely__returns_file_descriptor_not(void **state) {
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_dynamic_safely(f_string_empty_s, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_dynamic_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, 0);
+ const f_status_t status = f_print_to_except_in_dynamic_safely(test, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_dynamic_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_dynamic_safely()
*/
-extern void test__f_print_to_except_in_dynamic_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_dynamic_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_dynamic_safely()
*/
-extern void test__f_print_to_except_in_dynamic_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_dynamic_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_raw__parameter_checking(void **state) {
+void test__f_print_to_except_in_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, -1);
+ const f_status_t status = f_print_to_except_in_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_in_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_to_except_in_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_in_raw(test.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_in_raw__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_raw(0, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw(test.string, 2, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw(test.string, 1, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_raw()
*/
-extern void test__f_print_to_except_in_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_in_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_raw()
*/
-extern void test__f_print_to_except_in_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_in_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, -1);
+ const f_status_t status = f_print_to_except_in_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_in_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_to_except_in_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_in_raw_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_raw_safely(0, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 2, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_raw_safely(test.string, 1, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_raw_safely(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_raw_safely()
*/
-extern void test__f_print_to_except_in_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_raw_safely()
*/
-extern void test__f_print_to_except_in_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_in_safely__parameter_checking(void **state) {
+void test__f_print_to_except_in_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, -1);
+ const f_status_t status = f_print_to_except_in_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_in_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
- const f_string_ranges_t range = f_string_ranges_t_initialize;
{
- const f_status_t status = f_print_to_except_in_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 0, f_string_empty_s.used, except, range, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_in_safely(test.string, 0, f_string_empty_s.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(0, 0, test.used, except, range, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_in_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_string_ranges_t range = f_string_ranges_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_in_safely(0, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_in_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 0, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_safely(test.string, 2, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 2, test.used, except, range, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_in_safely(test.string, 1, test.used, except, range, 0);
+ const f_status_t status = f_print_to_except_in_safely(test.string, 1, test.used, except, range, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_in_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_in_safely()
*/
-extern void test__f_print_to_except_in_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_in_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_in_safely()
*/
-extern void test__f_print_to_except_in_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_in_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_raw__parameter_checking(void **state) {
+void test__f_print_to_except_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, -1);
+ const f_status_t status = f_print_to_except_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_to_except_raw(f_string_empty_s.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_raw(test.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_raw__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_raw(0, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw(test.string, 2, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw(test.string, 1, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_raw()
*/
-extern void test__f_print_to_except_raw__parameter_checking(void **state);
+extern void test__f_print_to_except_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_raw()
*/
-extern void test__f_print_to_except_raw__returns_data_not(void **state);
+extern void test__f_print_to_except_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_except_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, -1);
+ const f_status_t status = f_print_to_except_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_to_except_raw_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_raw_safely(test.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_raw_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_raw_safely(0, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw_safely(test.string, 2, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_raw_safely(test.string, 1, test.used, except, 0);
+ const f_status_t status = f_print_to_except_raw_safely(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_raw_safely()
*/
-extern void test__f_print_to_except_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_raw_safely()
*/
-extern void test__f_print_to_except_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_except_safely__parameter_checking(void **state) {
+void test__f_print_to_except_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, -1);
+ const f_status_t status = f_print_to_except_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_except_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
- const f_array_lengths_t except = f_array_lengths_t_initialize;
{
- const f_status_t status = f_print_to_except_safely(f_string_empty_s.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 0, f_string_empty_s.used, except, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_except_safely(test.string, 0, f_string_empty_s.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(0, 0, test.used, except, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_except_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_array_lengths_t except = f_array_lengths_t_initialize;
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_except_safely(0, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_except_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
const f_array_lengths_t except = f_array_lengths_t_initialize;
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 0, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_safely(test.string, 2, test.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 2, test.used, except, output);
assert_int_equal(status, F_none);
}
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_except_safely(test.string, 1, test.used, except, 0);
+ const f_status_t status = f_print_to_except_safely(test.string, 1, test.used, except, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_except_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_except_safely()
*/
-extern void test__f_print_to_except_safely__parameter_checking(void **state);
+extern void test__f_print_to_except_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_except_safely()
*/
-extern void test__f_print_to_except_safely__returns_data_not(void **state);
+extern void test__f_print_to_except_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_raw__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_raw(test.string, test.used, 0);
+ const f_status_t status = f_print_to_raw(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_raw__parameter_checking(void **state) {
+void test__f_print_to_raw__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw(test.string, test.used, -1);
+ const f_status_t status = f_print_to_raw(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_raw__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_to_raw(f_string_empty_s.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_raw(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_raw(test.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_raw(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_raw__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw(0, test.used, 0);
+ const f_status_t status = f_print_to_raw(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_raw__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
/*will_return(__wrap_write, false);
will_return(__wrap_write, 1);*/
- const f_status_t status = f_print_to_raw(test.string, test.used, 0);
+ const f_status_t status = f_print_to_raw(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_raw__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_raw()
*/
-extern void test__f_print_to_raw__parameter_checking(void **state);
+extern void test__f_print_to_raw__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_raw()
*/
-extern void test__f_print_to_raw__returns_data_not(void **state);
+extern void test__f_print_to_raw__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_raw_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_raw_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_to_raw_safely(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_raw_safely__parameter_checking(void **state) {
+void test__f_print_to_raw_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw_safely(test.string, test.used, -1);
+ const f_status_t status = f_print_to_raw_safely(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_raw_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_to_raw_safely(f_string_empty_s.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_raw_safely(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_raw_safely(test.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_raw_safely(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_raw_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw_safely(0, test.used, 0);
+ const f_status_t status = f_print_to_raw_safely(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_raw_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_raw_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_to_raw_safely(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_raw_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_raw_safely()
*/
-extern void test__f_print_to_raw_safely__parameter_checking(void **state);
+extern void test__f_print_to_raw_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_raw_safely()
*/
-extern void test__f_print_to_raw_safely__returns_data_not(void **state);
+extern void test__f_print_to_raw_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_raw_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_raw_terminated(test.string, 0);
+ const f_status_t status = f_print_to_raw_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_raw_terminated__parameter_checking(void **state) {
+void test__f_print_to_raw_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw_terminated(test.string, -1);
+ const f_status_t status = f_print_to_raw_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_raw_terminated__returns_data_not(void **state) {
+void test__f_print_to_raw_terminated__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_raw_terminated(0, 0);
+ const f_status_t status = f_print_to_raw_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_raw_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_raw_terminated(test.string, 0);
+ const f_status_t status = f_print_to_raw_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_raw_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_raw_terminated()
*/
-extern void test__f_print_to_raw_terminated__parameter_checking(void **state);
+extern void test__f_print_to_raw_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_raw_terminated()
*/
-extern void test__f_print_to_raw_terminated__returns_data_not(void **state);
+extern void test__f_print_to_raw_terminated__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_safely__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_to_safely(test.string, test.used, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_safely__parameter_checking(void **state) {
+void test__f_print_to_safely__returns_data_not(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_safely(test.string, test.used, -1);
+ const f_status_t status = f_print_to_safely(f_string_empty_s.string, f_string_empty_s.used, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
-}
-
-void test__f_print_to_safely__returns_data_not(void **state) {
-
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
{
- const f_status_t status = f_print_to_safely(f_string_empty_s.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_safely(test.string, f_string_empty_s.used, output);
assert_int_equal(status, F_data_not);
}
{
- const f_status_t status = f_print_to_safely(test.string, f_string_empty_s.used, 0);
+ const f_status_t status = f_print_to_safely(0, test.used, output);
assert_int_equal(status, F_data_not);
}
+}
+
+void test__f_print_to_safely__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_safely(0, test.used, 0);
+ const f_status_t status = f_print_to_safely(test.string, test.used, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_safely__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_safely(test.string, test.used, 0);
+ const f_status_t status = f_print_to_safely(test.string, test.used, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_safely__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_safely()
*/
-extern void test__f_print_to_safely__parameter_checking(void **state);
+extern void test__f_print_to_safely__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_safely()
*/
-extern void test__f_print_to_safely__returns_data_not(void **state);
+extern void test__f_print_to_safely__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_safely_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_safely_terminated(test.string, 0);
+ const f_status_t status = f_print_to_safely_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_safely_terminated__parameter_checking(void **state) {
+void test__f_print_to_safely_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_safely_terminated(test.string, -1);
+ const f_status_t status = f_print_to_safely_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_safely_terminated__returns_data_not(void **state) {
+void test__f_print_to_safely_terminated__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_safely_terminated(0, 0);
+ const f_status_t status = f_print_to_safely_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_safely_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_safely_terminated(test.string, 0);
+ const f_status_t status = f_print_to_safely_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_safely_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_safely_terminated()
*/
-extern void test__f_print_to_safely_terminated__parameter_checking(void **state);
+extern void test__f_print_to_safely_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_safely_terminated()
*/
-extern void test__f_print_to_safely_terminated__returns_data_not(void **state);
+extern void test__f_print_to_safely_terminated__returns_file_descriptor_not(void **state);
/**
* Test that function works.
void test__f_print_to_terminated__fails(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
int errnos[] = {
EAGAIN,
will_return(__wrap_write, true);
will_return(__wrap_write, errnos[i]);
- const f_status_t status = f_print_to_terminated(test.string, 0);
+ const f_status_t status = f_print_to_terminated(test.string, output);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
}
-void test__f_print_to_terminated__parameter_checking(void **state) {
+void test__f_print_to_terminated__returns_data_not(void **state) {
- const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_terminated(test.string, -1);
+ const f_status_t status = f_print_to_terminated(0, output);
- assert_int_equal(F_status_set_fine(status), F_parameter);
+ assert_int_equal(status, F_data_not);
}
}
-void test__f_print_to_terminated__returns_data_not(void **state) {
+void test__f_print_to_terminated__returns_file_descriptor_not(void **state) {
+
+ const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(0, -1, F_file_flag_write_only_d);
{
- const f_status_t status = f_print_to_terminated(0, 0);
+ const f_status_t status = f_print_to_terminated(test.string, output);
- assert_int_equal(status, F_data_not);
+ assert_int_equal(status, F_file_descriptor_not);
}
}
void test__f_print_to_terminated__works(void **state) {
const f_string_static_t test = macro_f_string_static_t_initialize_1("test", 0, 4);
+ const f_file_t output = macro_f_file_t_initialize_2(F_type_output_d, F_type_descriptor_output_d, F_file_flag_write_only_d);
{
will_return(__wrap_write, false);
will_return(__wrap_write, test.used);
- const f_status_t status = f_print_to_terminated(test.string, 0);
+ const f_status_t status = f_print_to_terminated(test.string, output);
assert_int_equal(status, F_none);
}
extern void test__f_print_to_terminated__fails(void **state);
/**
- * Test that parameter checking works as expected.
+ * Test that function works but returns F_data_not.
*
* @see f_print_to_terminated()
*/
-extern void test__f_print_to_terminated__parameter_checking(void **state);
+extern void test__f_print_to_terminated__returns_data_not(void **state);
/**
- * Test that function works but returns F_data_not.
+ * Test that function works but returns F_file_descriptor_not.
*
* @see f_print_to_terminated()
*/
-extern void test__f_print_to_terminated__returns_data_not(void **state);
+extern void test__f_print_to_terminated__returns_file_descriptor_not(void **state);
/**
* Test that function works.
const struct CMUnitTest tests[] = {
cmocka_unit_test(test__f_print__fails),
cmocka_unit_test(test__f_print__returns_data_not),
+ cmocka_unit_test(test__f_print__returns_stream_not),
cmocka_unit_test(test__f_print__works),
cmocka_unit_test(test__f_print_character__fails),
+ cmocka_unit_test(test__f_print_character__returns_stream_not),
cmocka_unit_test(test__f_print_character__works),
cmocka_unit_test(test__f_print_character_safely__fails),
+ cmocka_unit_test(test__f_print_character_safely__returns_stream_not),
cmocka_unit_test(test__f_print_character_safely__returns_utf),
cmocka_unit_test(test__f_print_character_safely__works),
cmocka_unit_test(test__f_print_dynamic__fails),
cmocka_unit_test(test__f_print_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic__works),
cmocka_unit_test(test__f_print_dynamic_partial__fails),
cmocka_unit_test(test__f_print_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_partial__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_partial__works),
cmocka_unit_test(test__f_print_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_partial_raw__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_partial_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_partial_safely__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_dynamic_raw__fails),
cmocka_unit_test(test__f_print_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_raw__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_raw__works),
cmocka_unit_test(test__f_print_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_dynamic_safely__fails),
cmocka_unit_test(test__f_print_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_dynamic_safely__returns_stream_not),
cmocka_unit_test(test__f_print_dynamic_safely__works),
cmocka_unit_test(test__f_print_except__fails),
cmocka_unit_test(test__f_print_except__returns_data_not),
+ cmocka_unit_test(test__f_print_except__returns_stream_not),
cmocka_unit_test(test__f_print_except__works),
cmocka_unit_test(test__f_print_except_dynamic__fails),
cmocka_unit_test(test__f_print_except_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic__works),
cmocka_unit_test(test__f_print_except_dynamic_partial__fails),
cmocka_unit_test(test__f_print_except_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_partial__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_partial__works),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_partial_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_partial_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_except_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_except_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_partial_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_except_dynamic_raw__fails),
cmocka_unit_test(test__f_print_except_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_raw__works),
cmocka_unit_test(test__f_print_except_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_except_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_except_dynamic_safely__fails),
cmocka_unit_test(test__f_print_except_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_dynamic_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_dynamic_safely__works),
cmocka_unit_test(test__f_print_except_in__fails),
cmocka_unit_test(test__f_print_except_in__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in__returns_stream_not),
cmocka_unit_test(test__f_print_except_in__works),
cmocka_unit_test(test__f_print_except_in_dynamic__fails),
cmocka_unit_test(test__f_print_except_in_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic__works),
cmocka_unit_test(test__f_print_except_in_dynamic_partial__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_partial__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_partial__works),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_partial_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_except_in_dynamic_raw__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_raw__works),
cmocka_unit_test(test__f_print_except_in_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_except_in_dynamic_safely__fails),
cmocka_unit_test(test__f_print_except_in_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_dynamic_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_dynamic_safely__works),
cmocka_unit_test(test__f_print_except_in_raw__fails),
cmocka_unit_test(test__f_print_except_in_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_raw__works),
cmocka_unit_test(test__f_print_except_in_raw_safely__fails),
cmocka_unit_test(test__f_print_except_in_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_raw_safely__works),
cmocka_unit_test(test__f_print_except_in_safely__fails),
cmocka_unit_test(test__f_print_except_in_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_in_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_in_safely__works),
cmocka_unit_test(test__f_print_except_raw__fails),
cmocka_unit_test(test__f_print_except_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_except_raw__returns_stream_not),
cmocka_unit_test(test__f_print_except_raw__works),
cmocka_unit_test(test__f_print_except_raw_safely__fails),
cmocka_unit_test(test__f_print_except_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_raw_safely__works),
cmocka_unit_test(test__f_print_except_safely__fails),
cmocka_unit_test(test__f_print_except_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_except_safely__returns_stream_not),
cmocka_unit_test(test__f_print_except_safely__works),
cmocka_unit_test(test__f_print_raw__fails),
cmocka_unit_test(test__f_print_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_raw__returns_stream_not),
cmocka_unit_test(test__f_print_raw__works),
cmocka_unit_test(test__f_print_raw_safely__fails),
cmocka_unit_test(test__f_print_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_raw_safely__returns_stream_not),
cmocka_unit_test(test__f_print_raw_safely__works),
cmocka_unit_test(test__f_print_raw_terminated__fails),
cmocka_unit_test(test__f_print_raw_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_raw_terminated__returns_stream_not),
cmocka_unit_test(test__f_print_raw_terminated__works),
cmocka_unit_test(test__f_print_safely__fails),
cmocka_unit_test(test__f_print_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_safely__returns_stream_not),
cmocka_unit_test(test__f_print_safely__works),
cmocka_unit_test(test__f_print_safely_get__returns_character_control),
cmocka_unit_test(test__f_print_safely_terminated__fails),
cmocka_unit_test(test__f_print_safely_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_safely_terminated__returns_stream_not),
cmocka_unit_test(test__f_print_safely_terminated__works),
cmocka_unit_test(test__f_print_terminated__fails),
cmocka_unit_test(test__f_print_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_terminated__returns_stream_not),
cmocka_unit_test(test__f_print_terminated__works),
cmocka_unit_test(test__f_print_to__fails),
cmocka_unit_test(test__f_print_to__returns_data_not),
+ cmocka_unit_test(test__f_print_to__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to__works),
cmocka_unit_test(test__f_print_to_character__fails),
+ cmocka_unit_test(test__f_print_to_character__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_character__works),
cmocka_unit_test(test__f_print_to_character_safely__fails),
+ cmocka_unit_test(test__f_print_to_character_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_character_safely__returns_utf),
cmocka_unit_test(test__f_print_to_character_safely__works),
cmocka_unit_test(test__f_print_to_dynamic__fails),
cmocka_unit_test(test__f_print_to_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic__works),
cmocka_unit_test(test__f_print_to_dynamic_partial__fails),
cmocka_unit_test(test__f_print_to_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_partial__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_partial__works),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_partial_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_partial_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_to_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_to_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_partial_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_to_dynamic_raw__fails),
cmocka_unit_test(test__f_print_to_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_raw__works),
cmocka_unit_test(test__f_print_to_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_to_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_to_dynamic_safely__fails),
cmocka_unit_test(test__f_print_to_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_dynamic_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_dynamic_safely__works),
cmocka_unit_test(test__f_print_to_except__fails),
cmocka_unit_test(test__f_print_to_except__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except__works),
cmocka_unit_test(test__f_print_to_except_dynamic__fails),
cmocka_unit_test(test__f_print_to_except_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic__works),
cmocka_unit_test(test__f_print_to_except_dynamic_partial__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_partial__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_partial__works),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_partial_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_to_except_dynamic_raw__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_raw__works),
cmocka_unit_test(test__f_print_to_except_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_dynamic_safely__fails),
cmocka_unit_test(test__f_print_to_except_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_dynamic_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_dynamic_safely__works),
cmocka_unit_test(test__f_print_to_except_in__fails),
cmocka_unit_test(test__f_print_to_except_in__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_partial__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_safely__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_in_dynamic_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_dynamic_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_dynamic_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_dynamic_safely__works),
cmocka_unit_test(test__f_print_to_except_in_raw__fails),
cmocka_unit_test(test__f_print_to_except_in_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_raw__works),
cmocka_unit_test(test__f_print_to_except_in_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_in_safely__fails),
cmocka_unit_test(test__f_print_to_except_in_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_in_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_in_safely__works),
cmocka_unit_test(test__f_print_to_except_raw__fails),
cmocka_unit_test(test__f_print_to_except_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_raw__works),
cmocka_unit_test(test__f_print_to_except_raw_safely__fails),
cmocka_unit_test(test__f_print_to_except_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_raw_safely__works),
cmocka_unit_test(test__f_print_to_except_safely__fails),
cmocka_unit_test(test__f_print_to_except_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_except_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_except_safely__works),
cmocka_unit_test(test__f_print_to_raw__fails),
cmocka_unit_test(test__f_print_to_raw__returns_data_not),
+ cmocka_unit_test(test__f_print_to_raw__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_raw__works),
cmocka_unit_test(test__f_print_to_raw_safely__fails),
cmocka_unit_test(test__f_print_to_raw_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_raw_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_raw_safely__works),
cmocka_unit_test(test__f_print_to_raw_terminated__fails),
cmocka_unit_test(test__f_print_to_raw_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_to_raw_terminated__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_raw_terminated__works),
cmocka_unit_test(test__f_print_to_safely__fails),
cmocka_unit_test(test__f_print_to_safely__returns_data_not),
+ cmocka_unit_test(test__f_print_to_safely__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_safely__works),
cmocka_unit_test(test__f_print_to_safely_terminated__fails),
cmocka_unit_test(test__f_print_to_safely_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_to_safely_terminated__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_safely_terminated__works),
cmocka_unit_test(test__f_print_to_terminated__fails),
cmocka_unit_test(test__f_print_to_terminated__returns_data_not),
+ cmocka_unit_test(test__f_print_to_terminated__returns_file_descriptor_not),
cmocka_unit_test(test__f_print_to_terminated__works),
#ifndef _di_level_0_parameter_checking_
- cmocka_unit_test(test__f_print__parameter_checking),
- cmocka_unit_test(test__f_print_character__parameter_checking),
- cmocka_unit_test(test__f_print_character_safely__parameter_checking),
+ // f_print() doesn't use parameter checking.
+ // f_print_character() doesn't use parameter checking.
+ // f_print_character_safely() doesn't use parameter checking.
// f_print_character_safely_get() doesn't use parameter checking.
- cmocka_unit_test(test__f_print_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_in_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_raw__parameter_checking),
- cmocka_unit_test(test__f_print_except_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_except_safely__parameter_checking),
- cmocka_unit_test(test__f_print_raw__parameter_checking),
- cmocka_unit_test(test__f_print_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_raw_terminated__parameter_checking),
- cmocka_unit_test(test__f_print_safely__parameter_checking),
+ // f_print_dynamic() doesn't use parameter checking.
+ // f_print_dynamic_partial() doesn't use parameter checking.
+ // f_print_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_dynamic_raw() doesn't use parameter checking.
+ // f_print_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_dynamic_safely() doesn't use parameter checking.
+ // f_print_except() doesn't use parameter checking.
+ // f_print_except_dynamic() doesn't use parameter checking.
+ // f_print_except_dynamic_partial() doesn't use parameter checking.
+ // f_print_except_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_except_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_except_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_except_dynamic_raw() doesn't use parameter checking.
+ // f_print_except_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_except_dynamic_safely() doesn't use parameter checking.
+ // f_print_except_in() doesn't use parameter checking.
+ // f_print_except_in_dynamic() doesn't use parameter checking.
+ // f_print_except_in_dynamic_partial() doesn't use parameter checking.
+ // f_print_except_in_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_except_in_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_except_in_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_except_in_dynamic_raw() doesn't use parameter checking.
+ // f_print_except_in_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_except_in_dynamic_safely() doesn't use parameter checking.
+ // f_print_except_in_raw() doesn't use parameter checking.
+ // f_print_except_in_raw_safely() doesn't use parameter checking.
+ // f_print_except_in_safely() doesn't use parameter checking.
+ // f_print_except_raw() doesn't use parameter checking.
+ // f_print_except_raw_safely() doesn't use parameter checking.
+ // f_print_except_safely() doesn't use parameter checking.
+ // f_print_raw() doesn't use parameter checking.
+ // f_print_raw_safely() doesn't use parameter checking.
+ // f_print_raw_terminated() doesn't use parameter checking.
+ // f_print_safely() doesn't use parameter checking.
// f_print_safely_get() doesn't use parameter checking.
- cmocka_unit_test(test__f_print_safely_terminated__parameter_checking),
- cmocka_unit_test(test__f_print_terminated__parameter_checking),
- cmocka_unit_test(test__f_print_to__parameter_checking),
- cmocka_unit_test(test__f_print_to_character__parameter_checking),
- cmocka_unit_test(test__f_print_to_character_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_partial__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_partial_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_dynamic_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_in_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_except_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_raw__parameter_checking),
- cmocka_unit_test(test__f_print_to_raw_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_raw_terminated__parameter_checking),
- cmocka_unit_test(test__f_print_to_safely__parameter_checking),
- cmocka_unit_test(test__f_print_to_safely_terminated__parameter_checking),
- cmocka_unit_test(test__f_print_to_terminated__parameter_checking),
+ // f_print_safely_terminated() doesn't use parameter checking.
+ // f_print_terminated() doesn't use parameter checking.
+ // f_print_to() doesn't use parameter checking.
+ // f_print_to_character() doesn't use parameter checking.
+ // f_print_to_character_safely() doesn't use parameter checking.
+ // f_print_to_dynamic() doesn't use parameter checking.
+ // f_print_to_dynamic_partial() doesn't use parameter checking.
+ // f_print_to_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_to_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_to_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_to_dynamic_raw() doesn't use parameter checking.
+ // f_print_to_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_to_dynamic_safely() doesn't use parameter checking.
+ // f_print_to_except() doesn't use parameter checking.
+ // f_print_to_except_dynamic() doesn't use parameter checking.
+ // f_print_to_except_dynamic_partial() doesn't use parameter checking.
+ // f_print_to_except_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_to_except_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_to_except_dynamic_raw() doesn't use parameter checking.
+ // f_print_to_except_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_dynamic_safely() doesn't use parameter checking.
+ // f_print_to_except_in() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_partial() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_partial_raw() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_partial_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_partial_safely() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_raw() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_in_dynamic_safely() doesn't use parameter checking.
+ // f_print_to_except_in_raw() doesn't use parameter checking.
+ // f_print_to_except_in_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_in_safely() doesn't use parameter checking.
+ // f_print_to_except_raw() doesn't use parameter checking.
+ // f_print_to_except_raw_safely() doesn't use parameter checking.
+ // f_print_to_except_safely() doesn't use parameter checking.
+ // f_print_to_raw() doesn't use parameter checking.
+ // f_print_to_raw_safely() doesn't use parameter checking.
+ // f_print_to_raw_terminated() doesn't use parameter checking.
+ // f_print_to_safely() doesn't use parameter checking.
+ // f_print_to_safely_terminated() doesn't use parameter checking.
+ // f_print_to_terminated() doesn't use parameter checking.
#endif // _di_level_0_parameter_checking_
};
f_status_t statuss[] = {
F_interrupt,
- F_parameter,
- F_failure,
+ F_status_set_error(F_parameter),
+ F_status_set_error(F_failure),
};
for (int i = 0; i < 3; ++i) {
const f_status_t status = f_signal_wait(&set, &information);
- assert_int_equal(status, F_status_set_error(statuss[i]));
+ assert_int_equal(status, statuss[i]);
} // for
}
f_status_t statuss[] = {
F_time_out,
- F_status_set_error(F_interrupt),
+ F_interrupt,
F_status_set_error(F_parameter),
F_status_set_error(F_failure),
};
F_ascii_not,
F_atomic,
F_atomic_not,
+ F_base,
+ F_base_not,
F_begin,
F_begin_not,
F_block,
F_block_not,
F_body,
F_body_not,
+ F_bottom,
+ F_bottom_not,
F_bound,
F_bound_not,
F_break,
F_call_not,
F_capability,
F_capability_not,
+ F_character,
+ F_character_not,
F_child,
F_child_not,
F_complete,
F_failure_not,
F_family,
F_family_not,
+ F_fifo,
+ F_fifo_not,
F_first,
F_first_not,
F_footer,
F_group_not,
F_halt,
F_halt_not,
- F_help,
- F_help_not,
F_header,
F_header_not,
+ F_help,
+ F_help_not,
F_ignore,
F_ignore_not,
F_implemented,
F_memory_not,
F_message,
F_message_not,
+ F_middle,
+ F_middle_not,
F_minor,
F_minor_not,
F_moderate,
F_recover_not,
F_recurse,
F_recurse_not,
+ F_regular,
+ F_regular_not,
F_relative,
F_relative_not,
F_remote,
F_time_out,
F_too_large,
F_too_small,
+ F_top,
+ F_top_not,
F_type,
F_type_not,
F_user,
F_complete_not_utf_eof,
F_complete_not_utf_eol,
F_complete_not_utf_eos,
+ F_complete_not_utf_start,
F_complete_not_utf_stop,
F_none_block,
F_none_eoa,
F_none_eof,
F_none_eol,
F_none_eos,
+ F_none_start,
F_none_stop,
F_data,
F_data_not,
F_data_not_eof,
F_data_not_eol,
F_data_not_eos,
+ F_data_not_start,
F_data_not_stop,
F_end,
F_end_not,
F_end_not_group_eof,
F_end_not_group_eol,
F_end_not_group_eos,
+ F_end_not_group_start,
F_end_not_group_stop,
F_end_not_nest,
F_end_not_nest_block,
F_end_not_nest_eof,
F_end_not_nest_eol,
F_end_not_nest_eos,
+ F_end_not_nest_start,
F_end_not_nest_stop,
+ F_end_not_start,
F_end_not_stop,
F_process,
F_process_not,
f_status_ascii_not_s,
f_status_atomic_s,
f_status_atomic_not_s,
+ f_status_base_s,
+ f_status_base_not_s,
f_status_begin_s,
f_status_begin_not_s,
f_status_block_s,
f_status_block_not_s,
f_status_body_s,
f_status_body_not_s,
+ f_status_bottom_s,
+ f_status_bottom_not_s,
f_status_bound_s,
f_status_bound_not_s,
f_status_break_s,
f_status_call_not_s,
f_status_capability_s,
f_status_capability_not_s,
+ f_status_character_s,
+ f_status_character_not_s,
f_status_child_s,
f_status_child_not_s,
f_status_complete_s,
f_status_failure_not_s,
f_status_family_s,
f_status_family_not_s,
+ f_status_fifo_s,
+ f_status_fifo_not_s,
f_status_first_s,
f_status_first_not_s,
f_status_footer_s,
f_status_group_not_s,
f_status_halt_s,
f_status_halt_not_s,
- f_status_help_s,
- f_status_help_not_s,
f_status_header_s,
f_status_header_not_s,
+ f_status_help_s,
+ f_status_help_not_s,
f_status_ignore_s,
f_status_ignore_not_s,
f_status_implemented_s,
f_status_memory_not_s,
f_status_message_s,
f_status_message_not_s,
+ f_status_middle_s,
+ f_status_middle_not_s,
f_status_minor_s,
f_status_minor_not_s,
f_status_moderate_s,
f_status_recover_not_s,
f_status_recurse_s,
f_status_recurse_not_s,
+ f_status_regular_s,
+ f_status_regular_not_s,
f_status_relative_s,
f_status_relative_not_s,
f_status_remote_s,
f_status_time_out_s,
f_status_too_large_s,
f_status_too_small_s,
+ f_status_top_s,
+ f_status_top_not_s,
f_status_type_s,
f_status_type_not_s,
f_status_user_s,
f_status_complete_not_utf_eof_s,
f_status_complete_not_utf_eol_s,
f_status_complete_not_utf_eos_s,
+ f_status_complete_not_utf_start_s,
f_status_complete_not_utf_stop_s,
f_status_none_block_s,
f_status_none_eoa_s,
f_status_none_eof_s,
f_status_none_eol_s,
f_status_none_eos_s,
+ f_status_none_start_s,
f_status_none_stop_s,
f_status_data_s,
f_status_data_not_s,
f_status_data_not_eof_s,
f_status_data_not_eol_s,
f_status_data_not_eos_s,
+ f_status_data_not_start_s,
f_status_data_not_stop_s,
f_status_end_s,
f_status_end_not_s,
f_status_end_not_group_eof_s,
f_status_end_not_group_eol_s,
f_status_end_not_group_eos_s,
+ f_status_end_not_group_start_s,
f_status_end_not_group_stop_s,
f_status_end_not_nest_s,
f_status_end_not_nest_block_s,
f_status_end_not_nest_eof_s,
f_status_end_not_nest_eol_s,
f_status_end_not_nest_eos_s,
+ f_status_end_not_nest_start_s,
f_status_end_not_nest_stop_s,
+ f_status_end_not_start_s,
f_status_end_not_stop_s,
f_status_process_s,
f_status_process_not_s,
f_status_status_code_last_s,
};
- for (uint16_t i = 0; i < 591; ++i) {
+ for (uint16_t i = 0; i < 611; ++i) {
f_string_static_t result = f_string_static_t_initialize;
will_return(__wrap_sem_open, true);
will_return(__wrap_sem_open, errnos[i]);
- const f_status_t status = f_thread_semaphore_file_open(name, flag, mode, value, &semaphore_ptr);
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, &mode, value, &semaphore_ptr);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
will_return(__wrap_sem_open, true);
will_return(__wrap_sem_open, errnos[i]);
- const f_status_t status = f_thread_semaphore_file_open(name, flag, mode, value, &semaphore_ptr);
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, &mode, value, &semaphore_ptr);
assert_int_equal(status, F_status_set_error(statuss[i]));
} // for
void test__f_thread_semaphore_file_open__parameter_checking(void **state) {
f_string_static_t name = macro_f_string_static_t_initialize_1("test", 0, 4);
+ f_thread_semaphore_t semaphore = f_thread_semaphore_t_initialize;
+ f_thread_semaphore_t *semaphore_ptr = &semaphore;
int flag = 0;
mode_t mode = 0;
unsigned value = 0;
{
- const f_status_t status = f_thread_semaphore_file_open(name, flag, mode, value, 0);
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, &mode, value, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+
+ {
+ flag = O_CREAT;
+
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, 0, value, &semaphore_ptr);
assert_int_equal(status, F_status_set_error(F_parameter));
}
{
will_return(__wrap_sem_open, false);
- const f_status_t status = f_thread_semaphore_file_open(name, flag, mode, value, &semaphore_ptr);
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, &mode, value, &semaphore_ptr);
assert_int_equal(status, F_none);
}
will_return(__wrap_sem_open, false);
- const f_status_t status = f_thread_semaphore_file_open(name, flag, mode, value, &semaphore_ptr);
+ const f_status_t status = f_thread_semaphore_file_open(name, flag, &mode, value, &semaphore_ptr);
assert_int_equal(status, F_none);
}
for (uint8_t i = 0; i < 24; ++i) {
- const f_status_t status = fll_path_canonical(contents[i], &path);
+ const f_status_t status = fl_path_canonical(contents[i], &path);
assert_int_equal(status, F_none);
f_string_dynamic_t path = f_string_dynamic_t_initialize;
{
- const f_status_t status = fll_path_canonical(f_string_empty_s, &path);
+ const f_status_t status = fl_path_canonical(f_string_empty_s, &path);
assert_int_equal(status, F_none);
assert_int_equal(pwd_length, path.used);
for (uint8_t i = 0; i < 18; ++i) {
- const f_status_t status = fll_path_canonical(contents[i], &path);
+ const f_status_t status = fl_path_canonical(contents[i], &path);
assert_int_equal(status, F_none);
for (uint8_t i = 0; i < 18; ++i) {
- const f_status_t status = fll_path_canonical(contents[i], &path);
+ const f_status_t status = fl_path_canonical(contents[i], &path);
// Assert_string_equal() is NULL terminated, so ensure NULL termination at end of path.used.
if (status == F_none) {
for (uint8_t i = 0; i < 23; ++i) {
- const f_status_t status = fll_path_canonical(contents[i], &path);
+ const f_status_t status = fl_path_canonical(contents[i], &path);
assert_int_equal(status, F_none);
void test__fll_path_canonical__parameter_checking(void **state) {
{
- const f_status_t status = fll_path_canonical(f_string_empty_s, 0);
+ const f_status_t status = fl_path_canonical(f_string_empty_s, 0);
assert_int_equal(status, F_status_set_error(F_parameter));
}
/**
* Test that function works with back paths (such as '../').
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__back_paths(void **state);
/**
* Test that function returns the present working directory when path is an empty string.
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__empty_becomes_pwd(void **state);
/**
* Test that function works with present directory paths.
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__present_paths(void **state);
/**
* Test that function works with root paths.
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__root_paths(void **state);
/**
* Test that function returns the string without expanding the tilde.
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__tilde_remains(void **state);
/**
* Test that parameter checking works as expected.
*
- * @see fll_path_canonical()
+ * @see fl_path_canonical()
*/
extern void test__fll_path_canonical__parameter_checking(void **state);
operate ld_library_path
- if exist build/programs/shared/test-fll_status_string
- shell build/programs/shared/test-fll_status_string
+ if exist build/programs/shared/test-fl_status_string
+ shell build/programs/shared/test-fl_status_string
- if exist build/programs/static/test-fll_status_string
- shell build/programs/static/test-fll_status_string
+ if exist build/programs/static/test-fl_status_string
+ shell build/programs/static/test-fl_status_string
- if not exist build/programs/shared/test-fll_status_string
- and not exist build/programs/static/test-fll_status_string
+ if not exist build/programs/shared/test-fl_status_string
+ and not exist build/programs/static/test-fl_status_string
operate not_created
not_created:
projects / fll / commitdiff