Several of the test files have the parameter_checking function out of order.
I also happened to notice that the work test in some cases are also out of order.
This out of order is likely a problem caused by early day mass test generation.
extern "C" {
#endif
+void test__f_string_append__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_append(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_append__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_append__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_append(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_append()
*/
-extern void test__f_string_append__works(void **state);
+extern void test__f_string_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_append()
*/
-extern void test__f_string_append__parameter_checking(void **state);
+extern void test__f_string_append__works(void **state);
#endif // _TEST__F_string_append_h
extern "C" {
#endif
+void test__f_string_append_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_append_assure(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_append_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_append_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_append_assure(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_append_assure()
*/
-extern void test__f_string_append_assure__works(void **state);
+extern void test__f_string_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_append_assure()
*/
-extern void test__f_string_append_assure__parameter_checking(void **state);
+extern void test__f_string_append_assure__works(void **state);
#endif // _TEST__F_string_append_assure_h
extern "C" {
#endif
+void test__f_string_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_append_assure_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_append_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_append_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_append_assure_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_append_assure_nulless()
*/
-extern void test__f_string_append_assure_nulless__works(void **state);
+extern void test__f_string_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_append_assure_nulless()
*/
-extern void test__f_string_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_append_assure_nulless__works(void **state);
#endif // _TEST__F_string_append_assure_nulless_h
extern "C" {
#endif
+void test__f_string_append_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_append_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_append_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_append_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_append_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_append_nulless()
*/
-extern void test__f_string_append_nulless__works(void **state);
+extern void test__f_string_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_append_nulless()
*/
-extern void test__f_string_append_nulless__parameter_checking(void **state);
+extern void test__f_string_append_nulless__works(void **state);
#endif // _TEST__F_string_append_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_append__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_append__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_append__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_append()
*/
-extern void test__f_string_dynamic_append__works(void **state);
+extern void test__f_string_dynamic_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_append()
*/
-extern void test__f_string_dynamic_append__parameter_checking(void **state);
+extern void test__f_string_dynamic_append__works(void **state);
#endif // _TEST__F_string_dynamic_append_h
extern "C" {
#endif
+void test__f_string_dynamic_append_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_append_assure(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_append_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_append_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_append_assure(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_append_assure()
*/
-extern void test__f_string_dynamic_append_assure__works(void **state);
+extern void test__f_string_dynamic_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_append_assure()
*/
-extern void test__f_string_dynamic_append_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_assure__works(void **state);
#endif // _TEST__F_string_dynamic_append_assure_h
extern "C" {
#endif
+void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_append_assure_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_append_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_append_assure_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_append_assure_nulless()
*/
-extern void test__f_string_dynamic_append_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_append_assure_nulless()
*/
-extern void test__f_string_dynamic_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_assure_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_append_assure_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_append_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_append_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_append_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_append_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_append_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_append_nulless()
*/
-extern void test__f_string_dynamic_append_nulless__works(void **state);
+extern void test__f_string_dynamic_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_append_nulless()
*/
-extern void test__f_string_dynamic_append_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_append_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_append_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_mash__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_dynamic_mash(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_mash__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_mash__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_dynamic_mash(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_mash()
*/
-extern void test__f_string_dynamic_mash__works(void **state);
+extern void test__f_string_dynamic_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_mash()
*/
-extern void test__f_string_dynamic_mash__parameter_checking(void **state);
+extern void test__f_string_dynamic_mash__works(void **state);
#endif // _TEST__F_string_dynamic_mash_h
extern "C" {
#endif
+void test__f_string_dynamic_mash_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_dynamic_mash_nulless(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_mash_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_mash_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_dynamic_mash_nulless(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_mash_nulless()
*/
-extern void test__f_string_dynamic_mash_nulless__works(void **state);
+extern void test__f_string_dynamic_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_mash_nulless()
*/
-extern void test__f_string_dynamic_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_mash_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_mash_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_mish__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_dynamic_mish(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_mish__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_mish__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_dynamic_mish(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_mish()
*/
-extern void test__f_string_dynamic_mish__works(void **state);
+extern void test__f_string_dynamic_mish__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_mish()
*/
-extern void test__f_string_dynamic_mish__parameter_checking(void **state);
+extern void test__f_string_dynamic_mish__works(void **state);
#endif // _TEST__F_string_dynamic_mish_h
extern "C" {
#endif
+void test__f_string_dynamic_mish_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_dynamic_mish_nulless(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_mish_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_mish_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_dynamic_mish_nulless(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_mish_nulless()
*/
-extern void test__f_string_dynamic_mish_nulless__works(void **state);
+extern void test__f_string_dynamic_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_mish_nulless()
*/
-extern void test__f_string_dynamic_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_mish_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_mish_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_append__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_append(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_append__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_append__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_append(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_append()
*/
-extern void test__f_string_dynamic_partial_append__works(void **state);
+extern void test__f_string_dynamic_partial_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_append()
*/
-extern void test__f_string_dynamic_partial_append__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append__works(void **state);
#endif // _TEST__F_string_dynamic_partial_append_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_append_assure(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_append_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_append_assure(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_append_assure()
*/
-extern void test__f_string_dynamic_partial_append_assure__works(void **state);
+extern void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_append_assure()
*/
-extern void test__f_string_dynamic_partial_append_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_assure__works(void **state);
#endif // _TEST__F_string_dynamic_partial_append_assure_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_append_assure_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_append_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_append_assure_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_append_assure_nulless()
*/
-extern void test__f_string_dynamic_partial_append_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_append_assure_nulless()
*/
-extern void test__f_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_assure_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_append_assure_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_append_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_append_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_append_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_append_nulless()
*/
-extern void test__f_string_dynamic_partial_append_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_append_nulless()
*/
-extern void test__f_string_dynamic_partial_append_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_append_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_append_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_mash__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_mash(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_mash__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_mash__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_mash(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_mash()
*/
-extern void test__f_string_dynamic_partial_mash__works(void **state);
+extern void test__f_string_dynamic_partial_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_mash()
*/
-extern void test__f_string_dynamic_partial_mash__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mash__works(void **state);
#endif // _TEST__F_string_dynamic_partial_mash_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_mash_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_mash_nulless()
*/
-extern void test__f_string_dynamic_partial_mash_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_mash_nulless()
*/
-extern void test__f_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mash_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_mash_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_mish__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_mish(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_mish__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_mish__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_mish(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_mish()
*/
-extern void test__f_string_dynamic_partial_mish__works(void **state);
+extern void test__f_string_dynamic_partial_mish__parameter_checking(void **state);
+
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_mish()
*/
-extern void test__f_string_dynamic_partial_mish__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mish__works(void **state);
#endif // _TEST__F_string_dynamic_partial_mish_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_mish_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_mish_nulless()
*/
-extern void test__f_string_dynamic_partial_mish_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_mish_nulless()
*/
-extern void test__f_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_mish_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_mish_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_prepend__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_prepend(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_prepend__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_prepend__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_prepend(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_prepend()
*/
-extern void test__f_string_dynamic_partial_prepend__works(void **state);
+extern void test__f_string_dynamic_partial_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_prepend()
*/
-extern void test__f_string_dynamic_partial_prepend__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend__works(void **state);
#endif // _TEST__F_string_dynamic_partial_prepend_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_prepend_assure(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_prepend_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_prepend_assure(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_prepend_assure()
*/
-extern void test__f_string_dynamic_partial_prepend_assure__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_prepend_assure()
*/
-extern void test__f_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure__works(void **state);
#endif // _TEST__F_string_dynamic_partial_prepend_assure_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_prepend_assure_nulless()
*/
-extern void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_prepend_assure_nulless()
*/
-extern void test__f_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_partial_prepend_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_partial_prepend_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("_te\0st_", 0, 7);
free((void *) destination.string);
}
-void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_partial_prepend_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_partial_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_partial_prepend_nulless()
*/
-extern void test__f_string_dynamic_partial_prepend_nulless__works(void **state);
+extern void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_partial_prepend_nulless()
*/
-extern void test__f_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_partial_prepend_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_partial_prepend_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_prepend__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_prepend(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_prepend__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_prepend__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_prepend(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_prepend()
*/
-extern void test__f_string_dynamic_prepend__works(void **state);
+extern void test__f_string_dynamic_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_prepend()
*/
-extern void test__f_string_dynamic_prepend__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend__works(void **state);
#endif // _TEST__F_string_dynamic_prepend_h
extern "C" {
#endif
+void test__f_string_dynamic_prepend_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_prepend_assure(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_prepend_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_prepend_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_prepend_assure(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_prepend_assure()
*/
-extern void test__f_string_dynamic_prepend_assure__works(void **state);
+extern void test__f_string_dynamic_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_prepend_assure()
*/
-extern void test__f_string_dynamic_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_assure__works(void **state);
#endif // _TEST__F_string_dynamic_prepend_assure_h
extern "C" {
#endif
+void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_prepend_assure_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_prepend_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_prepend_assure_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_prepend_assure_nulless()
*/
-extern void test__f_string_dynamic_prepend_assure_nulless__works(void **state);
+extern void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_prepend_assure_nulless()
*/
-extern void test__f_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_prepend_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_prepend_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_prepend_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamic_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_prepend_nulless()
*/
-extern void test__f_string_dynamic_prepend_nulless__works(void **state);
+extern void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_prepend_nulless()
*/
-extern void test__f_string_dynamic_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_dynamic_prepend_nulless__works(void **state);
#endif // _TEST__F_string_dynamic_prepend_nulless_h
extern "C" {
#endif
+void test__f_string_dynamic_seek_line__parameter_checking(void **state) {
+
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_dynamic_seek_line(source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_seek_line__returns_data_not_stop(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("test\nafter", 0, 10);
}
}
-void test__f_string_dynamic_seek_line__parameter_checking(void **state) {
-
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_dynamic_seek_line(source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_string_dynamic_seek_line_h
#define _TEST__F_string_dynamic_seek_line_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_line()
+ */
+extern void test__f_string_dynamic_seek_line__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_dynamic_seek_line__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_line()
- */
-extern void test__f_string_dynamic_seek_line__parameter_checking(void **state);
-
#endif // _TEST__F_string_dynamic_seek_line_h
}
}
+void test__f_string_dynamic_seek_line_to__parameter_checking(void **state) {
+
+ const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_dynamic_seek_line_to(source, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_seek_line_to__returns_data_not_stop(void **state) {
const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
}
}
-void test__f_string_dynamic_seek_line_to__parameter_checking(void **state) {
-
- const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_dynamic_seek_line_to(source, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
*/
extern void test__f_string_dynamic_seek_line_to__at_newline(void **state);
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_line_to()
+ */
+extern void test__f_string_dynamic_seek_line_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_dynamic_seek_line_to__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_line_to()
- */
-extern void test__f_string_dynamic_seek_line_to__parameter_checking(void **state);
-
#endif // _TEST__F_string_dynamic_seek_line_to_h
extern "C" {
#endif
+void test__f_string_dynamic_seek_to__parameter_checking(void **state) {
+
+ const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_dynamic_seek_to(source, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_seek_to__returns_data_not_stop(void **state) {
const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
}
}
-void test__f_string_dynamic_seek_to__parameter_checking(void **state) {
-
- const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_dynamic_seek_to(source, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_string_dynamic_seek_to_h
#define _TEST__F_string_dynamic_seek_to_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_seek_to()
+ */
+extern void test__f_string_dynamic_seek_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_dynamic_seek_to__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_seek_to()
- */
-extern void test__f_string_dynamic_seek_to__parameter_checking(void **state);
-
#endif // _TEST__F_string_dynamic_seek_to_h
extern "C" {
#endif
+void test__f_string_dynamic_strip_null__parameter_checking(void **state) {
+
+ {
+ const f_status_t status = f_string_dynamic_strip_null(0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_strip_null__returns_data_not(void **state) {
f_string_static_t buffer = f_string_static_t_initialize;
} // for
}
-void test__f_string_dynamic_strip_null__parameter_checking(void **state) {
-
- {
- const f_status_t status = f_string_dynamic_strip_null(0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_dynamic_strip_null_h
/**
- * Test that the function returns F_data_not because the buffer is empty.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamic_strip_null()
*/
-extern void test__f_string_dynamic_strip_null__returns_data_not(void **state);
+extern void test__f_string_dynamic_strip_null__parameter_checking(void **state);
/**
- * Test that the function works.
+ * Test that the function returns F_data_not because the buffer is empty.
*
* @see f_string_dynamic_strip_null()
*/
-extern void test__f_string_dynamic_strip_null__works(void **state);
+extern void test__f_string_dynamic_strip_null__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamic_strip_null()
*/
-extern void test__f_string_dynamic_strip_null__parameter_checking(void **state);
+extern void test__f_string_dynamic_strip_null__works(void **state);
#endif // _TEST__F_dynamic_strip_null_h
extern "C" {
#endif
+void test__f_string_dynamic_strip_null_range__parameter_checking(void **state) {
+
+ const f_range_t range = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamic_strip_null_range(range, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamic_strip_null_range__returns_data_not(void **state) {
f_string_static_t buffer = f_string_static_t_initialize;
} // for
}
-void test__f_string_dynamic_strip_null_range__parameter_checking(void **state) {
-
- const f_range_t range = f_range_t_initialize;
-
- {
- const f_status_t status = f_string_dynamic_strip_null_range(range, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_dynamic_strip_null_range_h
#define _TEST__F_dynamic_strip_null_range_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_dynamic_strip_null_range()
+ */
+extern void test__f_string_dynamic_strip_null_range__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not because the buffer is empty.
*
*/
extern void test__f_string_dynamic_strip_null_range__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_dynamic_strip_null_range()
- */
-extern void test__f_string_dynamic_strip_null_range__parameter_checking(void **state);
-
#endif // _TEST__F_dynamic_strip_null_range_h
extern "C" {
#endif
+void test__f_string_dynamics_append__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamics_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_dynamics_append__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.array);
}
-void test__f_string_dynamics_append__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_dynamics_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamics_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamics_append()
*/
-extern void test__f_string_dynamics_append__works(void **state);
+extern void test__f_string_dynamics_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamics_append()
*/
-extern void test__f_string_dynamics_append__parameter_checking(void **state);
+extern void test__f_string_dynamics_append__works(void **state);
#endif // _TEST__F_string_dynamics_append_h
extern "C" {
#endif
+void test__f_string_dynamics_append_all__parameter_checking(void **state) {
+
+ const f_string_dynamics_t data = f_string_dynamics_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamics_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_dynamics_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_dynamics_t source = f_string_dynamics_t_initialize;
+ f_string_dynamics_t destination = f_string_dynamics_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_dynamics_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_dynamics_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_dynamics_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_dynamics_t source = f_string_dynamics_t_initialize;
- f_string_dynamics_t destination = f_string_dynamics_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_dynamics_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_dynamics_append_all__parameter_checking(void **state) {
-
- const f_string_dynamics_t data = f_string_dynamics_t_initialize;
-
- {
- const f_status_t status = f_string_dynamics_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamics_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamics_append_all()
*/
-extern void test__f_string_dynamics_append_all__works(void **state);
+extern void test__f_string_dynamics_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_dynamics_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamics_append_all()
*/
-extern void test__f_string_dynamics_append_all__parameter_checking(void **state);
+extern void test__f_string_dynamics_append_all__works(void **state);
#endif // _TEST__F_string_dynamics_append_all_h
extern "C" {
#endif
+void test__f_string_dynamicss_append__parameter_checking(void **state) {
+
+ f_string_dynamics_t data = f_string_dynamics_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamicss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_dynamicss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_dynamics_t source = f_string_dynamicss_t_initialize;
+ f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_dynamicss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_dynamicss_append__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_dynamicss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_dynamics_t source = f_string_dynamicss_t_initialize;
- f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamic_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamics_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_dynamicss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_dynamicss_append__parameter_checking(void **state) {
-
- f_string_dynamics_t data = f_string_dynamics_t_initialize;
-
- {
- const f_status_t status = f_string_dynamicss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamicss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamicss_append()
*/
-extern void test__f_string_dynamicss_append__works(void **state);
+extern void test__f_string_dynamicss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_dynamicss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamicss_append()
*/
-extern void test__f_string_dynamicss_append__parameter_checking(void **state);
+extern void test__f_string_dynamicss_append__works(void **state);
#endif // _TEST__F_string_dynamicss_append_h
extern "C" {
#endif
+void test__f_string_dynamicss_append_all__parameter_checking(void **state) {
+
+ const f_string_dynamicss_t data = f_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_string_dynamicss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_dynamicss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_dynamicss_t source = f_string_dynamicss_t_initialize;
+ f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamics_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamicss_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_dynamicss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_dynamicss_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_dynamicss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_dynamicss_t source = f_string_dynamicss_t_initialize;
- f_string_dynamicss_t destination = f_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_dynamics_t), (void **) &source.array, &source.used, &source.size, &f_string_dynamicss_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_dynamicss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_dynamicss_append_all__parameter_checking(void **state) {
-
- const f_string_dynamicss_t data = f_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_string_dynamicss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_dynamicss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_dynamicss_append_all()
*/
-extern void test__f_string_dynamicss_append_all__works(void **state);
+extern void test__f_string_dynamicss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_dynamicss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_dynamicss_append_all()
*/
-extern void test__f_string_dynamicss_append_all__parameter_checking(void **state);
+extern void test__f_string_dynamicss_append_all__works(void **state);
#endif // _TEST__F_string_dynamicss_append_all_h
extern "C" {
#endif
+void test__f_string_map_multis_append__parameter_checking(void **state) {
+
+ const f_string_map_multi_t data = f_string_map_multi_t_initialize;
+
+ {
+ const f_status_t status = f_string_map_multis_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_map_multis_append__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_string_map_multis_append__parameter_checking(void **state) {
-
- const f_string_map_multi_t data = f_string_map_multi_t_initialize;
-
- {
- const f_status_t status = f_string_map_multis_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_map_multis_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_map_multis_append()
*/
-extern void test__f_string_map_multis_append__works(void **state);
+extern void test__f_string_map_multis_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_map_multis_append()
*/
-extern void test__f_string_map_multis_append__parameter_checking(void **state);
+extern void test__f_string_map_multis_append__works(void **state);
#endif // _TEST__F_string_map_multis_append_h
extern "C" {
#endif
+void test__f_string_map_multis_append_all__parameter_checking(void **state) {
+
+ const f_string_map_multis_t data = f_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_string_map_multis_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_map_multis_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_map_multis_t source = f_string_map_multis_t_initialize;
+ f_string_map_multis_t destination = f_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_map_multis_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_map_multis_append_all__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_string_map_multis_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_map_multis_t source = f_string_map_multis_t_initialize;
- f_string_map_multis_t destination = f_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_map_multis_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_map_multis_append_all__parameter_checking(void **state) {
-
- const f_string_map_multis_t data = f_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_string_map_multis_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_map_multis_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_map_multis_append_all()
*/
-extern void test__f_string_map_multis_append_all__works(void **state);
+extern void test__f_string_map_multis_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_map_multis_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_map_multis_append_all()
*/
-extern void test__f_string_map_multis_append_all__parameter_checking(void **state);
+extern void test__f_string_map_multis_append_all__works(void **state);
#endif // _TEST__F_string_map_multis_append_all_h
extern "C" {
#endif
+void test__f_string_map_multiss_append__parameter_checking(void **state) {
+
+ f_string_map_multis_t data = f_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_string_map_multiss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_map_multiss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_map_multis_t source = f_string_map_multiss_t_initialize;
+ f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_map_multiss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_map_multiss_append__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_string_map_multiss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_map_multis_t source = f_string_map_multiss_t_initialize;
- f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multi_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multis_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_map_multiss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_map_multiss_append__parameter_checking(void **state) {
-
- f_string_map_multis_t data = f_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_string_map_multiss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_map_multiss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_map_multiss_append()
*/
-extern void test__f_string_map_multiss_append__works(void **state);
+extern void test__f_string_map_multiss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_map_multiss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_map_multiss_append()
*/
-extern void test__f_string_map_multiss_append__parameter_checking(void **state);
+extern void test__f_string_map_multiss_append__works(void **state);
#endif // _TEST__F_string_map_multiss_append_h
extern "C" {
#endif
+void test__f_string_map_multiss_append_all__parameter_checking(void **state) {
+
+ const f_string_map_multiss_t data = f_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_string_map_multiss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_map_multiss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_map_multiss_t source = f_string_map_multiss_t_initialize;
+ f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multis_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multiss_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_map_multiss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_map_multiss_append_all__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_string_map_multiss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_map_multiss_t source = f_string_map_multiss_t_initialize;
- f_string_map_multiss_t destination = f_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_multis_t), (void **) &source.array, &source.used, &source.size, &f_string_map_multiss_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_map_multiss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_map_multiss_append_all__parameter_checking(void **state) {
-
- const f_string_map_multiss_t data = f_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_string_map_multiss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_map_multiss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_map_multiss_append_all()
*/
-extern void test__f_string_map_multiss_append_all__works(void **state);
+extern void test__f_string_map_multiss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_map_multiss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_map_multiss_append_all()
*/
-extern void test__f_string_map_multiss_append_all__parameter_checking(void **state);
+extern void test__f_string_map_multiss_append_all__works(void **state);
#endif // _TEST__F_string_map_multiss_append_all_h
extern "C" {
#endif
+void test__f_string_maps_append__parameter_checking(void **state) {
+
+ const f_string_map_t data = f_string_map_t_initialize;
+
+ {
+ const f_status_t status = f_string_maps_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_maps_append__works(void **state) {
f_string_map_t source = f_string_map_t_initialize;
free((void *) destination.array);
}
-void test__f_string_maps_append__parameter_checking(void **state) {
-
- const f_string_map_t data = f_string_map_t_initialize;
-
- {
- const f_status_t status = f_string_maps_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_maps_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_maps_append()
*/
-extern void test__f_string_maps_append__works(void **state);
+extern void test__f_string_maps_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_maps_append()
*/
-extern void test__f_string_maps_append__parameter_checking(void **state);
+extern void test__f_string_maps_append__works(void **state);
#endif // _TEST__F_string_maps_append_h
extern "C" {
#endif
+void test__f_string_maps_append_all__parameter_checking(void **state) {
+
+ const f_string_maps_t data = f_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_string_maps_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_maps_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_maps_t source = f_string_maps_t_initialize;
+ f_string_maps_t destination = f_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_maps_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_maps_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_maps_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_maps_t source = f_string_maps_t_initialize;
- f_string_maps_t destination = f_string_maps_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_maps_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_maps_append_all__parameter_checking(void **state) {
-
- const f_string_maps_t data = f_string_maps_t_initialize;
-
- {
- const f_status_t status = f_string_maps_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_maps_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_maps_append_all()
*/
-extern void test__f_string_maps_append_all__works(void **state);
+extern void test__f_string_maps_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_maps_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_maps_append_all()
*/
-extern void test__f_string_maps_append_all__parameter_checking(void **state);
+extern void test__f_string_maps_append_all__works(void **state);
#endif // _TEST__F_string_maps_append_all_h
extern "C" {
#endif
+void test__f_string_mapss_append__parameter_checking(void **state) {
+
+ f_string_maps_t data = f_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_string_mapss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_mapss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_maps_t source = f_string_mapss_t_initialize;
+ f_string_mapss_t destination = f_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_mapss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_mapss_append__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_mapss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_maps_t source = f_string_mapss_t_initialize;
- f_string_mapss_t destination = f_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_map_t), (void **) &source.array, &source.used, &source.size, &f_string_maps_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_mapss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_mapss_append__parameter_checking(void **state) {
-
- f_string_maps_t data = f_string_maps_t_initialize;
-
- {
- const f_status_t status = f_string_mapss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mapss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mapss_append()
*/
-extern void test__f_string_mapss_append__works(void **state);
+extern void test__f_string_mapss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_mapss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mapss_append()
*/
-extern void test__f_string_mapss_append__parameter_checking(void **state);
+extern void test__f_string_mapss_append__works(void **state);
#endif // _TEST__F_string_mapss_append_h
extern "C" {
#endif
+void test__f_string_mapss_append_all__parameter_checking(void **state) {
+
+ const f_string_mapss_t data = f_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_string_mapss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_mapss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_mapss_t source = f_string_mapss_t_initialize;
+ f_string_mapss_t destination = f_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_maps_t), (void **) &source.array, &source.used, &source.size, &f_string_mapss_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_mapss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_mapss_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_string_mapss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_mapss_t source = f_string_mapss_t_initialize;
- f_string_mapss_t destination = f_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_maps_t), (void **) &source.array, &source.used, &source.size, &f_string_mapss_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_mapss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_mapss_append_all__parameter_checking(void **state) {
-
- const f_string_mapss_t data = f_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_string_mapss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mapss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mapss_append_all()
*/
-extern void test__f_string_mapss_append_all__works(void **state);
+extern void test__f_string_mapss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_mapss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mapss_append_all()
*/
-extern void test__f_string_mapss_append_all__parameter_checking(void **state);
+extern void test__f_string_mapss_append_all__works(void **state);
#endif // _TEST__F_string_mapss_append_all_h
extern "C" {
#endif
+void test__f_string_mash__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_mash(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_mash__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_mash__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_mash(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mash()
*/
-extern void test__f_string_mash__works(void **state);
+extern void test__f_string_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mash()
*/
-extern void test__f_string_mash__parameter_checking(void **state);
+extern void test__f_string_mash__works(void **state);
#endif // _TEST__F_string_mash_h
extern "C" {
#endif
+void test__f_string_mash_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_mash_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_mash_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mash_nulless()
*/
-extern void test__f_string_mash_nulless__works(void **state);
+extern void test__f_string_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mash_nulless()
*/
-extern void test__f_string_mash_nulless__parameter_checking(void **state);
+extern void test__f_string_mash_nulless__works(void **state);
#endif // _TEST__F_string_mash_nulless_h
extern "C" {
#endif
+void test__f_string_mish__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_mish(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_mish__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_mish__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_mish(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mish()
*/
-extern void test__f_string_mish__works(void **state);
+extern void test__f_string_mish__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mish()
*/
-extern void test__f_string_mish__parameter_checking(void **state);
+extern void test__f_string_mish__works(void **state);
#endif // _TEST__F_string_mish_h
extern "C" {
#endif
+void test__f_string_mish_nulless__parameter_checking(void **state) {
+
+ const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
+
+ {
+ const f_status_t status = f_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_mish_nulless__works(void **state) {
const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
free((void *) destination.string);
}
-void test__f_string_mish_nulless__parameter_checking(void **state) {
-
- const f_string_static_t glue = macro_f_string_static_t_initialize_1(":", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
-
- {
- const f_status_t status = f_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_mish_nulless()
*/
-extern void test__f_string_mish_nulless__works(void **state);
+extern void test__f_string_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_mish_nulless()
*/
-extern void test__f_string_mish_nulless__parameter_checking(void **state);
+extern void test__f_string_mish_nulless__works(void **state);
#endif // _TEST__F_string_mish_nulless_h
extern "C" {
#endif
+void test__f_string_prepend__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_prepend(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_prepend__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_prepend__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_prepend(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_prepend()
*/
-extern void test__f_string_prepend__works(void **state);
+extern void test__f_string_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_prepend()
*/
-extern void test__f_string_prepend__parameter_checking(void **state);
+extern void test__f_string_prepend__works(void **state);
#endif // _TEST__F_string_prepend_h
extern "C" {
#endif
+void test__f_string_prepend_assure__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_prepend_assure(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_prepend_assure__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_prepend_assure__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_prepend_assure(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_prepend_assure()
*/
-extern void test__f_string_prepend_assure__works(void **state);
+extern void test__f_string_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_prepend_assure()
*/
-extern void test__f_string_prepend_assure__parameter_checking(void **state);
+extern void test__f_string_prepend_assure__works(void **state);
#endif // _TEST__F_string_prepend_assure_h
extern "C" {
#endif
+void test__f_string_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_prepend_assure_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_prepend_assure_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_prepend_assure_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_prepend_assure_nulless()
*/
-extern void test__f_string_prepend_assure_nulless__works(void **state);
+extern void test__f_string_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_prepend_assure_nulless()
*/
-extern void test__f_string_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_string_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_string_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_string_prepend_nulless__parameter_checking(void **state) {
+
+ const f_string_dynamic_t data = f_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_string_prepend_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_prepend_nulless__works(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("te\0st", 0, 5);
free((void *) destination.string);
}
-void test__f_string_prepend_nulless__parameter_checking(void **state) {
-
- const f_string_dynamic_t data = f_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_string_prepend_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_prepend_nulless()
*/
-extern void test__f_string_prepend_nulless__works(void **state);
+extern void test__f_string_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_prepend_nulless()
*/
-extern void test__f_string_prepend_nulless__parameter_checking(void **state);
+extern void test__f_string_prepend_nulless__works(void **state);
#endif // _TEST__F_string_prepend_nulless_h
extern "C" {
#endif
+void test__f_string_seek_line__parameter_checking(void **state) {
+
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_seek_line(source.string, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_seek_line__returns_data_not_stop(void **state) {
const f_string_static_t source = macro_f_string_static_t_initialize_1("test\nafter", 0, 10);
}
}
-void test__f_string_seek_line__parameter_checking(void **state) {
-
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_seek_line(source.string, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_string_seek_line_h
#define _TEST__F_string_seek_line_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_line()
+ */
+extern void test__f_string_seek_line__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_seek_line__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_line()
- */
-extern void test__f_string_seek_line__parameter_checking(void **state);
-
#endif // _TEST__F_string_seek_line_h
}
}
+void test__f_string_seek_line_to__parameter_checking(void **state) {
+
+ const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_seek_line_to(source.string, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_seek_line_to__returns_data_not_stop(void **state) {
const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
}
}
-void test__f_string_seek_line_to__parameter_checking(void **state) {
-
- const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_seek_line_to(source.string, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
*/
extern void test__f_string_seek_line_to__at_newline(void **state);
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_line_to()
+ */
+extern void test__f_string_seek_line_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_seek_line_to__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_line_to()
- */
-extern void test__f_string_seek_line_to__parameter_checking(void **state);
-
#endif // _TEST__F_string_seek_line_to_h
extern "C" {
#endif
+void test__f_string_seek_to__parameter_checking(void **state) {
+
+ const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
+ const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
+
+ {
+ const f_status_t status = f_string_seek_to(source.string, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_seek_to__returns_data_not_stop(void **state) {
const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
}
}
-void test__f_string_seek_to__parameter_checking(void **state) {
-
- const f_string_static_t to = macro_f_string_static_t_initialize_1("X", 0, 1);
- const f_string_static_t source = macro_f_string_static_t_initialize_1("teX\nst", 0, 6);
-
- {
- const f_status_t status = f_string_seek_to(source.string, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_string_seek_to_h
#define _TEST__F_string_seek_to_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_string_seek_to()
+ */
+extern void test__f_string_seek_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_string_seek_to__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_string_seek_to()
- */
-extern void test__f_string_seek_to__parameter_checking(void **state);
-
#endif // _TEST__F_string_seek_to_h
extern "C" {
#endif
+void test__f_string_triples_append__parameter_checking(void **state) {
+
+ const f_string_triple_t data = f_string_triple_t_initialize;
+
+ {
+ const f_status_t status = f_string_triples_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_string_triples_append__works(void **state) {
const f_string_static_t test_a = macro_f_string_static_t_initialize_1("a", 0, 1);
free((void *) destination.array);
}
-void test__f_string_triples_append__parameter_checking(void **state) {
-
- const f_string_triple_t data = f_string_triple_t_initialize;
-
- {
- const f_status_t status = f_string_triples_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_triples_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_triples_append()
*/
-extern void test__f_string_triples_append__works(void **state);
+extern void test__f_string_triples_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_triples_append()
*/
-extern void test__f_string_triples_append__parameter_checking(void **state);
+extern void test__f_string_triples_append__works(void **state);
#endif // _TEST__F_string_triples_append_h
extern "C" {
#endif
+void test__f_string_triples_append_all__parameter_checking(void **state) {
+
+ const f_string_triples_t data = f_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_string_triples_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_triples_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_triples_t source = f_string_triples_t_initialize;
+ f_string_triples_t destination = f_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_triples_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_triples_append_all__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_string_triples_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_triples_t source = f_string_triples_t_initialize;
- f_string_triples_t destination = f_string_triples_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_triples_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_triples_append_all__parameter_checking(void **state) {
-
- const f_string_triples_t data = f_string_triples_t_initialize;
-
- {
- const f_status_t status = f_string_triples_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_triples_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_triples_append_all()
*/
-extern void test__f_string_triples_append_all__works(void **state);
+extern void test__f_string_triples_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_triples_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_triples_append_all()
*/
-extern void test__f_string_triples_append_all__parameter_checking(void **state);
+extern void test__f_string_triples_append_all__works(void **state);
#endif // _TEST__F_string_triples_append_all_h
extern "C" {
#endif
+void test__f_string_tripless_append__parameter_checking(void **state) {
+
+ f_string_triples_t data = f_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_string_tripless_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_tripless_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_triples_t source = f_string_tripless_t_initialize;
+ f_string_tripless_t destination = f_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_tripless_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_tripless_append__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_string_tripless_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_triples_t source = f_string_tripless_t_initialize;
- f_string_tripless_t destination = f_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triple_t), (void **) &source.array, &source.used, &source.size, &f_string_triples_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_tripless_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_tripless_append__parameter_checking(void **state) {
-
- f_string_triples_t data = f_string_triples_t_initialize;
-
- {
- const f_status_t status = f_string_tripless_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_tripless_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_tripless_append()
*/
-extern void test__f_string_tripless_append__works(void **state);
+extern void test__f_string_tripless_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_tripless_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_tripless_append()
*/
-extern void test__f_string_tripless_append__parameter_checking(void **state);
+extern void test__f_string_tripless_append__works(void **state);
#endif // _TEST__F_string_tripless_append_h
extern "C" {
#endif
+void test__f_string_tripless_append_all__parameter_checking(void **state) {
+
+ const f_string_tripless_t data = f_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_string_tripless_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_string_tripless_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_string_tripless_t source = f_string_tripless_t_initialize;
+ f_string_tripless_t destination = f_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triples_t), (void **) &source.array, &source.used, &source.size, &f_string_tripless_delete_callback);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_string_tripless_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_string_tripless_append_all__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_string_tripless_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_string_tripless_t source = f_string_tripless_t_initialize;
- f_string_tripless_t destination = f_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_memory_arrays_resize(length, sizeof(f_string_triples_t), (void **) &source.array, &source.used, &source.size, &f_string_tripless_delete_callback);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_string_tripless_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_string_tripless_append_all__parameter_checking(void **state) {
-
- const f_string_tripless_t data = f_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_string_tripless_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_string_tripless_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_string_tripless_append_all()
*/
-extern void test__f_string_tripless_append_all__works(void **state);
+extern void test__f_string_tripless_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_string_tripless_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_string_tripless_append_all()
*/
-extern void test__f_string_tripless_append_all__parameter_checking(void **state);
+extern void test__f_string_tripless_append_all__works(void **state);
#endif // _TEST__F_string_tripless_append_all_h
extern "C" {
#endif
+void test__f_utf_append__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_append(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_append__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_append__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_append(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_append()
*/
-extern void test__f_utf_append__works(void **state);
+extern void test__f_utf_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_append()
*/
-extern void test__f_utf_append__parameter_checking(void **state);
+extern void test__f_utf_append__works(void **state);
#endif // _TEST__F_utf_append_h
extern "C" {
#endif
+void test__f_utf_append_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_append_assure(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_append_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_append_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_append_assure(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_append_assure()
*/
-extern void test__f_utf_append_assure__works(void **state);
+extern void test__f_utf_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_append_assure()
*/
-extern void test__f_utf_append_assure__parameter_checking(void **state);
+extern void test__f_utf_append_assure__works(void **state);
#endif // _TEST__F_utf_append_assure_h
extern "C" {
#endif
+void test__f_utf_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_append_assure_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_append_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_append_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_append_assure_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_append_assure_nulless()
*/
-extern void test__f_utf_append_assure_nulless__works(void **state);
+extern void test__f_utf_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_append_assure_nulless()
*/
-extern void test__f_utf_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_append_assure_nulless__works(void **state);
#endif // _TEST__F_utf_append_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_append_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_append_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_append_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_append_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_append_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_append_nulless()
*/
-extern void test__f_utf_append_nulless__works(void **state);
+extern void test__f_utf_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_append_nulless()
*/
-extern void test__f_utf_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_append_nulless__works(void **state);
#endif // _TEST__F_utf_append_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_append_assure(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_append_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_append_assure(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_append_assure()
*/
-extern void test__f_utf_string_dynamic_append_assure__works(void **state);
+extern void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_append_assure()
*/
-extern void test__f_utf_string_dynamic_append_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_assure__works(void **state);
#endif // _TEST__F_utf_dynamic_append_assure_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_append_assure_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_append_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_append_assure_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_append_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_append_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_append_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_assure_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_append_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_append_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_append_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_append_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_append_nulless()
*/
-extern void test__f_utf_string_dynamic_append_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_append_nulless()
*/
-extern void test__f_utf_string_dynamic_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_append_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_append_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_mash__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_mash(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_mash__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_mash__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_dynamic_mash(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_mash()
*/
-extern void test__f_utf_string_dynamic_mash__works(void **state);
+extern void test__f_utf_string_dynamic_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_mash()
*/
-extern void test__f_utf_string_dynamic_mash__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mash__works(void **state);
#endif // _TEST__F_utf_dynamic_mash_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_mash_nulless(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_mash_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_dynamic_mash_nulless(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_mash_nulless()
*/
-extern void test__f_utf_string_dynamic_mash_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_mash_nulless()
*/
-extern void test__f_utf_string_dynamic_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mash_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_mash_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_mish__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_mish(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_mish__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_mish__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_dynamic_mish(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_mish()
*/
-extern void test__f_utf_string_dynamic_mish__works(void **state);
+extern void test__f_utf_string_dynamic_mish__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_mish()
*/
-extern void test__f_utf_string_dynamic_mish__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mish__works(void **state);
#endif // _TEST__F_utf_dynamic_mish_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_mish_nulless(glue, source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_mish_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_dynamic_mish_nulless(glue, source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_mish_nulless()
*/
-extern void test__f_utf_string_dynamic_mish_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_mish_nulless()
*/
-extern void test__f_utf_string_dynamic_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_mish_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_mish_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_append(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_append__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_append(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_append()
*/
-extern void test__f_utf_string_dynamic_partial_append__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_append()
*/
-extern void test__f_utf_string_dynamic_partial_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_append_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_append_assure(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_append_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_append_assure(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_append_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_append_assure()
*/
-extern void test__f_utf_string_dynamic_partial_append_assure__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_append_assure()
*/
-extern void test__f_utf_string_dynamic_partial_append_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_append_assure_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_append_assure_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_append_assure_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_append_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_append_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_append_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_append_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_assure_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_append_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_append_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_append_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_append_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_append_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_append_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_append_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_append_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_append_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_append_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_append_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_mash(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_mash__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_mash(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_mash()
*/
-extern void test__f_utf_string_dynamic_partial_mash__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_mash()
*/
-extern void test__f_utf_string_dynamic_partial_mash__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mash__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_mash_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_mash_nulless(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_mash_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_mash_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mash_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_mash_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_mish(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_mish__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_mish(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_mish()
*/
-extern void test__f_utf_string_dynamic_partial_mish__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state);
+
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_mish()
*/
-extern void test__f_utf_string_dynamic_partial_mish__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mish__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_mish_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_mish_nulless(glue, source, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_mish_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_mish_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_mish_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_mish_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_prepend(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_prepend__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_prepend(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_prepend()
*/
-extern void test__f_utf_string_dynamic_partial_prepend__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_prepend()
*/
-extern void test__f_utf_string_dynamic_partial_prepend__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_prepend_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_prepend_assure(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_prepend_assure(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_prepend_assure()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_prepend_assure()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_prepend_assure_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_prepend_assure_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_prepend_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_prepend_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+ const f_range_t partial = f_range_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_partial_prepend_nulless(data, partial, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0_\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t\0\0\0_", 0, 7);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
- const f_range_t partial = f_range_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_partial_prepend_nulless(data, partial, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_partial_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_partial_prepend_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_partial_prepend_nulless()
*/
-extern void test__f_utf_string_dynamic_partial_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_partial_prepend_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_partial_prepend_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_prepend__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_prepend(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_prepend__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_prepend__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_prepend(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_prepend()
*/
-extern void test__f_utf_string_dynamic_prepend__works(void **state);
+extern void test__f_utf_string_dynamic_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_prepend()
*/
-extern void test__f_utf_string_dynamic_prepend__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend__works(void **state);
#endif // _TEST__F_utf_dynamic_prepend_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_prepend_assure(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_prepend_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_prepend_assure(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_prepend_assure()
*/
-extern void test__f_utf_string_dynamic_prepend_assure__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_prepend_assure()
*/
-extern void test__f_utf_string_dynamic_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure__works(void **state);
#endif // _TEST__F_utf_dynamic_prepend_assure_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_prepend_assure_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_prepend_assure_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_prepend_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_prepend_assure_nulless()
*/
-extern void test__f_utf_string_dynamic_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamic_prepend_nulless(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_prepend_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamic_prepend_nulless(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamic_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamic_prepend_nulless()
*/
-extern void test__f_utf_string_dynamic_prepend_nulless__works(void **state);
+extern void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamic_prepend_nulless()
*/
-extern void test__f_utf_string_dynamic_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_string_dynamic_prepend_nulless__works(void **state);
#endif // _TEST__F_utf_dynamic_prepend_nulless_h
extern "C" {
#endif
+void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state) {
+
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_seek_line(source, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_seek_line__returns_data_not_stop(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0s\0\0\0t\0\0\0\n\0\0\0a\0\0\0f\0\0\0t\0\0\0e\0\0\0r", 0, 10);
}
}
-void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state) {
-
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_dynamic_seek_line(source, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_utf_dynamic_seek_line_h
#define _TEST__F_utf_dynamic_seek_line_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_line()
+ */
+extern void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_utf_string_dynamic_seek_line__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_line()
- */
-extern void test__f_utf_string_dynamic_seek_line__parameter_checking(void **state);
-
#endif // _TEST__F_utf_dynamic_seek_line_h
}
}
+void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state) {
+
+ const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_seek_line_to(source, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_seek_line_to__returns_data_not_stop(void **state) {
const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
}
}
-void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state) {
-
- const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_dynamic_seek_line_to(source, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
*/
extern void test__f_utf_string_dynamic_seek_line_to__before_newline(void **state);
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_line_to()
+ */
+extern void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_utf_string_dynamic_seek_line_to__returns_none_stop(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_line_to()
- */
-extern void test__f_utf_string_dynamic_seek_line_to__parameter_checking(void **state);
-
#endif // _TEST__F_utf_dynamic_seek_line_to_h
}
}
+void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state) {
+
+ const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_dynamic_seek_to(source, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamic_seek_to__returns_data_not_stop(void **state) {
const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
}
}
-void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state) {
-
- const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_dynamic_seek_to(source, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
*/
extern void test__f_utf_string_dynamic_seek_to__before_newline(void **state);
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_dynamic_seek_to()
+ */
+extern void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_utf_string_dynamic_seek_to__returns_none_stop(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_dynamic_seek_to()
- */
-extern void test__f_utf_string_dynamic_seek_to__parameter_checking(void **state);
-
#endif // _TEST__F_utf_dynamic_seek_to_h
extern "C" {
#endif
+void test__f_utf_string_dynamics_append__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamics_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamics_append__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.array);
}
-void test__f_utf_string_dynamics_append__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamics_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamics_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamics_append()
*/
-extern void test__f_utf_string_dynamics_append__works(void **state);
+extern void test__f_utf_string_dynamics_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamics_append()
*/
-extern void test__f_utf_string_dynamics_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamics_append__works(void **state);
#endif // _TEST__F_utf_dynamics_append_h
extern "C" {
#endif
+void test__f_utf_string_dynamics_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamics_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_dynamics_append_all__works(void **state) {
const int length_inner = 2;
free((void *) source.array);
}
-void test__f_utf_string_dynamics_append_all__parameter_checking(void **state) {
-
- const f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamics_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamics_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamics_append_all()
*/
-extern void test__f_utf_string_dynamics_append_all__works(void **state);
+extern void test__f_utf_string_dynamics_append_all__parameter_checking(void **state);
/**
- * Test that the function returns F_data_not when asked to copy an empty structure.
+ * Test that the function works.
*
* @see f_utf_string_dynamics_append_all()
*/
-extern void test__f_utf_string_dynamics_append_all__returns_data_not(void **state);
+extern void test__f_utf_string_dynamics_append_all__works(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_data_not when asked to copy an empty structure.
*
* @see f_utf_string_dynamics_append_all()
*/
-extern void test__f_utf_string_dynamics_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_dynamics_append_all__returns_data_not(void **state);
#endif // _TEST__F_utf_dynamics_append_all_h
extern "C" {
#endif
+void test__f_utf_string_dynamicss_append__parameter_checking(void **state) {
+
+ f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamicss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_dynamicss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_dynamics_t source = f_utf_string_dynamicss_t_initialize;
+ f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamic_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_dynamicss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_dynamicss_append__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_utf_string_dynamicss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_dynamics_t source = f_utf_string_dynamicss_t_initialize;
- f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamic_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_dynamicss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_dynamicss_append__parameter_checking(void **state) {
-
- f_utf_string_dynamics_t data = f_utf_string_dynamics_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamicss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamicss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamicss_append()
*/
-extern void test__f_utf_string_dynamicss_append__works(void **state);
+extern void test__f_utf_string_dynamicss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_dynamicss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamicss_append()
*/
-extern void test__f_utf_string_dynamicss_append__parameter_checking(void **state);
+extern void test__f_utf_string_dynamicss_append__works(void **state);
#endif // _TEST__F_utf_dynamicss_append_h
extern "C" {
#endif
+void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_dynamicss_t data = f_utf_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_dynamicss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_dynamicss_t source = f_utf_string_dynamicss_t_initialize;
+ f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamics_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_dynamicss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_dynamicss_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_dynamicss_t source = f_utf_string_dynamicss_t_initialize;
- f_utf_string_dynamicss_t destination = f_utf_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_dynamics_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_dynamicss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state) {
-
- const f_utf_string_dynamicss_t data = f_utf_string_dynamicss_t_initialize;
-
- {
- const f_status_t status = f_utf_string_dynamicss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_dynamicss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_dynamicss_append_all()
*/
-extern void test__f_utf_string_dynamicss_append_all__works(void **state);
+extern void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_dynamicss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_dynamicss_append_all()
*/
-extern void test__f_utf_string_dynamicss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_dynamicss_append_all__works(void **state);
#endif // _TEST__F_utf_dynamicss_append_all_h
extern "C" {
#endif
+void test__f_utf_string_map_multis_append__parameter_checking(void **state) {
+
+ const f_utf_string_map_multi_t data = f_utf_string_map_multi_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_map_multis_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_map_multis_append__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_utf_string_map_multis_append__parameter_checking(void **state) {
-
- const f_utf_string_map_multi_t data = f_utf_string_map_multi_t_initialize;
-
- {
- const f_status_t status = f_utf_string_map_multis_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_map_multis_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_map_multis_append()
*/
-extern void test__f_utf_string_map_multis_append__works(void **state);
+extern void test__f_utf_string_map_multis_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_map_multis_append()
*/
-extern void test__f_utf_string_map_multis_append__parameter_checking(void **state);
+extern void test__f_utf_string_map_multis_append__works(void **state);
#endif // _TEST__F_utf_map_multis_append_h
extern "C" {
#endif
+void test__f_utf_string_map_multis_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_map_multis_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_map_multis_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_map_multis_t source = f_utf_string_map_multis_t_initialize;
+ f_utf_string_map_multis_t destination = f_utf_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_map_multis_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_map_multis_append_all__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_utf_string_map_multis_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_map_multis_t source = f_utf_string_map_multis_t_initialize;
- f_utf_string_map_multis_t destination = f_utf_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_map_multis_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_map_multis_append_all__parameter_checking(void **state) {
-
- const f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_utf_string_map_multis_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_map_multis_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_map_multis_append_all()
*/
-extern void test__f_utf_string_map_multis_append_all__works(void **state);
+extern void test__f_utf_string_map_multis_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_map_multis_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_map_multis_append_all()
*/
-extern void test__f_utf_string_map_multis_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_map_multis_append_all__works(void **state);
#endif // _TEST__F_utf_map_multis_append_all_h
extern "C" {
#endif
+void test__f_utf_string_map_multiss_append__parameter_checking(void **state) {
+
+ f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_map_multiss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_map_multiss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_map_multis_t source = f_utf_string_map_multiss_t_initialize;
+ f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_map_multiss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_map_multiss_append__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_utf_string_map_multiss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_map_multis_t source = f_utf_string_map_multiss_t_initialize;
- f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_map_multiss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_map_multiss_append__parameter_checking(void **state) {
-
- f_utf_string_map_multis_t data = f_utf_string_map_multis_t_initialize;
-
- {
- const f_status_t status = f_utf_string_map_multiss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_map_multiss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_map_multiss_append()
*/
-extern void test__f_utf_string_map_multiss_append__works(void **state);
+extern void test__f_utf_string_map_multiss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_map_multiss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_map_multiss_append()
*/
-extern void test__f_utf_string_map_multiss_append__parameter_checking(void **state);
+extern void test__f_utf_string_map_multiss_append__works(void **state);
#endif // _TEST__F_utf_map_multiss_append_h
extern "C" {
#endif
+void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_map_multiss_t data = f_utf_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_map_multiss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_map_multiss_t source = f_utf_string_map_multiss_t_initialize;
+ f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_map_multiss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_map_multiss_append_all__works(void **state) {
const int length_values = 2;
free((void *) destination.array);
}
-void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_map_multiss_t source = f_utf_string_map_multiss_t_initialize;
- f_utf_string_map_multiss_t destination = f_utf_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_multis_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_map_multiss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state) {
-
- const f_utf_string_map_multiss_t data = f_utf_string_map_multiss_t_initialize;
-
- {
- const f_status_t status = f_utf_string_map_multiss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_map_multiss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_map_multiss_append_all()
*/
-extern void test__f_utf_string_map_multiss_append_all__works(void **state);
+extern void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_map_multiss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_map_multiss_append_all()
*/
-extern void test__f_utf_string_map_multiss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_map_multiss_append_all__works(void **state);
#endif // _TEST__F_utf_map_multiss_append_all_h
extern "C" {
#endif
+void test__f_utf_string_maps_append__parameter_checking(void **state) {
+
+ const f_utf_string_map_t data = f_utf_string_map_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_maps_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_maps_append__works(void **state) {
f_utf_string_map_t source = f_utf_string_map_t_initialize;
free((void *) destination.array);
}
-void test__f_utf_string_maps_append__parameter_checking(void **state) {
-
- const f_utf_string_map_t data = f_utf_string_map_t_initialize;
-
- {
- const f_status_t status = f_utf_string_maps_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_maps_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_maps_append()
*/
-extern void test__f_utf_string_maps_append__works(void **state);
+extern void test__f_utf_string_maps_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_maps_append()
*/
-extern void test__f_utf_string_maps_append__parameter_checking(void **state);
+extern void test__f_utf_string_maps_append__works(void **state);
#endif // _TEST__F_utf_maps_append_h
extern "C" {
#endif
+void test__f_utf_string_maps_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_maps_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_maps_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_maps_t source = f_utf_string_maps_t_initialize;
+ f_utf_string_maps_t destination = f_utf_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_maps_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_maps_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_utf_string_maps_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_maps_t source = f_utf_string_maps_t_initialize;
- f_utf_string_maps_t destination = f_utf_string_maps_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_map_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_maps_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_maps_append_all__parameter_checking(void **state) {
-
- const f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
-
- {
- const f_status_t status = f_utf_string_maps_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_maps_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_maps_append_all()
*/
-extern void test__f_utf_string_maps_append_all__works(void **state);
+extern void test__f_utf_string_maps_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_maps_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_maps_append_all()
*/
-extern void test__f_utf_string_maps_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_maps_append_all__works(void **state);
#endif // _TEST__F_utf_maps_append_all_h
extern "C" {
#endif
+void test__f_utf_string_mapss_append__parameter_checking(void **state) {
+
+ f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_mapss_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_mapss_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_maps_t source = f_utf_string_mapss_t_initialize;
+ f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_mapss_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_mapss_append__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_utf_string_mapss_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_maps_t source = f_utf_string_mapss_t_initialize;
- f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_mapss_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_mapss_append__parameter_checking(void **state) {
-
- f_utf_string_maps_t data = f_utf_string_maps_t_initialize;
-
- {
- const f_status_t status = f_utf_string_mapss_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mapss_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mapss_append()
*/
-extern void test__f_utf_string_mapss_append__works(void **state);
+extern void test__f_utf_string_mapss_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_mapss_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mapss_append()
*/
-extern void test__f_utf_string_mapss_append__parameter_checking(void **state);
+extern void test__f_utf_string_mapss_append__works(void **state);
#endif // _TEST__F_utf_mapss_append_h
extern "C" {
#endif
+void test__f_utf_string_mapss_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_mapss_t data = f_utf_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_mapss_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_mapss_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_mapss_t source = f_utf_string_mapss_t_initialize;
+ f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_mapss_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_mapss_append_all__works(void **state) {
const int length_inner = 2;
free((void *) destination.array);
}
-void test__f_utf_string_mapss_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_mapss_t source = f_utf_string_mapss_t_initialize;
- f_utf_string_mapss_t destination = f_utf_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_maps_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_mapss_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_mapss_append_all__parameter_checking(void **state) {
-
- const f_utf_string_mapss_t data = f_utf_string_mapss_t_initialize;
-
- {
- const f_status_t status = f_utf_string_mapss_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mapss_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mapss_append_all()
*/
-extern void test__f_utf_string_mapss_append_all__works(void **state);
+extern void test__f_utf_string_mapss_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_mapss_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mapss_append_all()
*/
-extern void test__f_utf_string_mapss_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_mapss_append_all__works(void **state);
#endif // _TEST__F_utf_mapss_append_all_h
extern "C" {
#endif
+void test__f_utf_mash__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_mash(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_mash__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_mash__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_mash(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mash_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mash()
*/
-extern void test__f_utf_mash__works(void **state);
+extern void test__f_utf_mash__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mash()
*/
-extern void test__f_utf_mash__parameter_checking(void **state);
+extern void test__f_utf_mash__works(void **state);
#endif // _TEST__F_utf_mash_h
extern "C" {
#endif
+void test__f_utf_mash_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_mash_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_mash_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_mash_nulless(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mash_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mash_nulless()
*/
-extern void test__f_utf_mash_nulless__works(void **state);
+extern void test__f_utf_mash_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mash_nulless()
*/
-extern void test__f_utf_mash_nulless__parameter_checking(void **state);
+extern void test__f_utf_mash_nulless__works(void **state);
#endif // _TEST__F_utf_mash_nulless_h
extern "C" {
#endif
+void test__f_utf_mish__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_mish(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_mish__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_mish__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_mish(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mish_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mish()
*/
-extern void test__f_utf_mish__works(void **state);
+extern void test__f_utf_mish__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mish()
*/
-extern void test__f_utf_mish__parameter_checking(void **state);
+extern void test__f_utf_mish__works(void **state);
#endif // _TEST__F_utf_mish_h
extern "C" {
#endif
+void test__f_utf_mish_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
+
+ {
+ const f_status_t status = f_utf_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_mish_nulless__works(void **state) {
const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
free((void *) destination.string);
}
-void test__f_utf_mish_nulless__parameter_checking(void **state) {
-
- const f_utf_string_static_t glue = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0:", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
-
- {
- const f_status_t status = f_utf_string_mish_nulless(glue.string, glue.used, source.string, source.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_mish_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_mish_nulless()
*/
-extern void test__f_utf_mish_nulless__works(void **state);
+extern void test__f_utf_mish_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_mish_nulless()
*/
-extern void test__f_utf_mish_nulless__parameter_checking(void **state);
+extern void test__f_utf_mish_nulless__works(void **state);
#endif // _TEST__F_utf_mish_nulless_h
extern "C" {
#endif
+void test__f_utf_prepend__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_prepend(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_prepend__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_prepend__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_prepend(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_prepend_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_prepend()
*/
-extern void test__f_utf_prepend__works(void **state);
+extern void test__f_utf_prepend__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_prepend()
*/
-extern void test__f_utf_prepend__parameter_checking(void **state);
+extern void test__f_utf_prepend__works(void **state);
#endif // _TEST__F_utf_prepend_h
extern "C" {
#endif
+void test__f_utf_prepend_assure__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_prepend_assure(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_prepend_assure__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_prepend_assure__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_prepend_assure(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_prepend_assure_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_prepend_assure()
*/
-extern void test__f_utf_prepend_assure__works(void **state);
+extern void test__f_utf_prepend_assure__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_prepend_assure()
*/
-extern void test__f_utf_prepend_assure__parameter_checking(void **state);
+extern void test__f_utf_prepend_assure__works(void **state);
#endif // _TEST__F_utf_prepend_assure_h
extern "C" {
#endif
+void test__f_utf_prepend_assure_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_prepend_assure_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_prepend_assure_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_prepend_assure_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_prepend_assure_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_prepend_assure_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_prepend_assure_nulless()
*/
-extern void test__f_utf_prepend_assure_nulless__works(void **state);
+extern void test__f_utf_prepend_assure_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_prepend_assure_nulless()
*/
-extern void test__f_utf_prepend_assure_nulless__parameter_checking(void **state);
+extern void test__f_utf_prepend_assure_nulless__works(void **state);
#endif // _TEST__F_utf_prepend_assure_nulless_h
extern "C" {
#endif
+void test__f_utf_prepend_nulless__parameter_checking(void **state) {
+
+ const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_prepend_nulless(data.string, data.used, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_prepend_nulless__works(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0\0\0\0\0s\0\0\0t", 0, 5);
free((void *) destination.string);
}
-void test__f_utf_prepend_nulless__parameter_checking(void **state) {
-
- const f_utf_string_dynamic_t data = f_utf_string_dynamic_t_initialize;
-
- {
- const f_status_t status = f_utf_string_prepend_nulless(data.string, data.used, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_prepend_nulless_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_prepend_nulless()
*/
-extern void test__f_utf_prepend_nulless__works(void **state);
+extern void test__f_utf_prepend_nulless__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_prepend_nulless()
*/
-extern void test__f_utf_prepend_nulless__parameter_checking(void **state);
+extern void test__f_utf_prepend_nulless__works(void **state);
#endif // _TEST__F_utf_prepend_nulless_h
extern "C" {
#endif
+void test__f_utf_seek_line__parameter_checking(void **state) {
+
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_seek_line(source.string, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_seek_line__returns_data_not_stop(void **state) {
const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0s\0\0\0t\0\0\0\n\0\0\0a\0\0\0f\0\0\0t\0\0\0e\0\0\0r", 0, 10);
}
}
-void test__f_utf_seek_line__parameter_checking(void **state) {
-
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_seek_line(source.string, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#ifndef _TEST__F_utf_seek_line_h
#define _TEST__F_utf_seek_line_h
+/**
+ * Test that the function correctly fails on invalid parameter.
+ *
+ * @see f_utf_string_seek_line()
+ */
+extern void test__f_utf_seek_line__parameter_checking(void **state);
+
/**
* Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
*/
extern void test__f_utf_seek_line__works(void **state);
-/**
- * Test that the function correctly fails on invalid parameter.
- *
- * @see f_utf_string_seek_line()
- */
-extern void test__f_utf_seek_line__parameter_checking(void **state);
-
#endif // _TEST__F_utf_seek_line_h
}
}
+void test__f_utf_seek_line_to__parameter_checking(void **state) {
+
+ const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_seek_line_to(source.string, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_seek_line_to__returns_data_not_stop(void **state) {
const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
}
}
-void test__f_utf_seek_line_to__parameter_checking(void **state) {
-
- const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_seek_line_to(source.string, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
extern void test__f_utf_seek_line_to__before_newline(void **state);
/**
- * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_seek_line_to()
*/
-extern void test__f_utf_seek_line_to__returns_data_not_stop(void **state);
+extern void test__f_utf_seek_line_to__parameter_checking(void **state);
/**
- * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
+ * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
* @see f_utf_string_seek_line_to()
*/
-extern void test__f_utf_seek_line_to__returns_none_stop(void **state);
+extern void test__f_utf_seek_line_to__returns_data_not_stop(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
*
* @see f_utf_string_seek_line_to()
*/
-extern void test__f_utf_seek_line_to__parameter_checking(void **state);
+extern void test__f_utf_seek_line_to__returns_none_stop(void **state);
#endif // _TEST__F_utf_seek_line_to_h
}
}
+void test__f_utf_seek_to__parameter_checking(void **state) {
+
+ const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
+ const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
+
+ {
+ const f_status_t status = f_utf_string_seek_to(source.string, to.string[0], 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_seek_to__returns_data_not_stop(void **state) {
const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
}
}
-void test__f_utf_seek_to__parameter_checking(void **state) {
-
- const f_utf_string_static_t to = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0X", 0, 1);
- const f_utf_string_static_t source = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0t\0\0\0e\0\0\0X\0\0\0\n\0\0\0s\0\0\0t", 0, 6);
-
- {
- const f_status_t status = f_utf_string_seek_to(source.string, to.string[0], 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
extern void test__f_utf_seek_to__before_newline(void **state);
/**
- * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_seek_to()
*/
-extern void test__f_utf_seek_to__returns_data_not_stop(void **state);
+extern void test__f_utf_seek_to__parameter_checking(void **state);
/**
- * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
+ * Test that the function returns F_data_not_stop because range is an empty range (range.start > range.stop).
*
* @see f_utf_string_seek_to()
*/
-extern void test__f_utf_seek_to__returns_none_stop(void **state);
+extern void test__f_utf_seek_to__returns_data_not_stop(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function returns F_okay_stop stopped after end of range because no newline is found.
*
* @see f_utf_string_seek_to()
*/
-extern void test__f_utf_seek_to__parameter_checking(void **state);
+extern void test__f_utf_seek_to__returns_none_stop(void **state);
#endif // _TEST__F_utf_seek_to_h
extern "C" {
#endif
+void test__f_utf_string_triples_append__parameter_checking(void **state) {
+
+ const f_utf_string_triple_t data = f_utf_string_triple_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_triples_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
void test__f_utf_string_triples_append__works(void **state) {
const f_utf_string_static_t test_a = macro_f_utf_string_static_t_initialize_1((f_utf_string_t) "\0\0\0a", 0, 1);
free((void *) destination.array);
}
-void test__f_utf_string_triples_append__parameter_checking(void **state) {
-
- const f_utf_string_triple_t data = f_utf_string_triple_t_initialize;
-
- {
- const f_status_t status = f_utf_string_triples_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_triples_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_triples_append()
*/
-extern void test__f_utf_string_triples_append__works(void **state);
+extern void test__f_utf_string_triples_append__parameter_checking(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_triples_append()
*/
-extern void test__f_utf_string_triples_append__parameter_checking(void **state);
+extern void test__f_utf_string_triples_append__works(void **state);
#endif // _TEST__F_utf_triples_append_h
extern "C" {
#endif
+void test__f_utf_string_triples_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_triples_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_triples_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_triples_t source = f_utf_string_triples_t_initialize;
+ f_utf_string_triples_t destination = f_utf_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triple_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_triples_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_triples_append_all__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_utf_string_triples_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_triples_t source = f_utf_string_triples_t_initialize;
- f_utf_string_triples_t destination = f_utf_string_triples_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triple_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_triples_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_triples_append_all__parameter_checking(void **state) {
-
- const f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
-
- {
- const f_status_t status = f_utf_string_triples_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_triples_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_triples_append_all()
*/
-extern void test__f_utf_string_triples_append_all__works(void **state);
+extern void test__f_utf_string_triples_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_triples_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_triples_append_all()
*/
-extern void test__f_utf_string_triples_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_triples_append_all__works(void **state);
#endif // _TEST__F_utf_triples_append_all_h
extern "C" {
#endif
+void test__f_utf_string_tripless_append__parameter_checking(void **state) {
+
+ f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_tripless_append(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_tripless_append__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_triples_t source = f_utf_string_tripless_t_initialize;
+ f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_tripless_append(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_tripless_append__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_utf_string_tripless_append__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_triples_t source = f_utf_string_tripless_t_initialize;
- f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_tripless_append(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_tripless_append__parameter_checking(void **state) {
-
- f_utf_string_triples_t data = f_utf_string_triples_t_initialize;
-
- {
- const f_status_t status = f_utf_string_tripless_append(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_tripless_append_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_tripless_append()
*/
-extern void test__f_utf_string_tripless_append__works(void **state);
+extern void test__f_utf_string_tripless_append__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_tripless_append__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_tripless_append()
*/
-extern void test__f_utf_string_tripless_append__parameter_checking(void **state);
+extern void test__f_utf_string_tripless_append__works(void **state);
#endif // _TEST__F_utf_tripless_append_h
extern "C" {
#endif
+void test__f_utf_string_tripless_append_all__parameter_checking(void **state) {
+
+ const f_utf_string_tripless_t data = f_utf_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_utf_string_tripless_append_all(data, 0);
+
+ assert_int_equal(status, F_status_set_error(F_parameter));
+ }
+}
+
+void test__f_utf_string_tripless_append_all__returns_data_not(void **state) {
+
+ const int length = 5;
+ f_utf_string_tripless_t source = f_utf_string_tripless_t_initialize;
+ f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
+
+ {
+ const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
+
+ assert_int_equal(status, F_okay);
+ assert_int_equal(source.used, 0);
+ assert_int_equal(source.size, length);
+ }
+
+ {
+ const f_status_t status = f_utf_string_tripless_append_all(source, &destination);
+
+ assert_int_equal(status, F_data_not);
+ assert_int_equal(destination.used, 0);
+ assert_int_equal(destination.size, 0);
+ assert_null(destination.array);
+ }
+
+ free((void *) source.array);
+}
+
void test__f_utf_string_tripless_append_all__works(void **state) {
const int length_sources = 2;
free((void *) destination.array);
}
-void test__f_utf_string_tripless_append_all__returns_data_not(void **state) {
-
- const int length = 5;
- f_utf_string_tripless_t source = f_utf_string_tripless_t_initialize;
- f_utf_string_tripless_t destination = f_utf_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_memory_array_increase_by(length, sizeof(f_utf_string_triples_t), (void **) &source.array, &source.used, &source.size);
-
- assert_int_equal(status, F_okay);
- assert_int_equal(source.used, 0);
- assert_int_equal(source.size, length);
- }
-
- {
- const f_status_t status = f_utf_string_tripless_append_all(source, &destination);
-
- assert_int_equal(status, F_data_not);
- assert_int_equal(destination.used, 0);
- assert_int_equal(destination.size, 0);
- assert_null(destination.array);
- }
-
- free((void *) source.array);
-}
-
-void test__f_utf_string_tripless_append_all__parameter_checking(void **state) {
-
- const f_utf_string_tripless_t data = f_utf_string_tripless_t_initialize;
-
- {
- const f_status_t status = f_utf_string_tripless_append_all(data, 0);
-
- assert_int_equal(status, F_status_set_error(F_parameter));
- }
-}
-
#ifdef __cplusplus
} // extern "C"
#endif
#define _TEST__F_utf_tripless_append_all_h
/**
- * Test that the function works.
+ * Test that the function correctly fails on invalid parameter.
*
* @see f_utf_string_tripless_append_all()
*/
-extern void test__f_utf_string_tripless_append_all__works(void **state);
+extern void test__f_utf_string_tripless_append_all__parameter_checking(void **state);
/**
* Test that the function returns F_data_not when asked to copy an empty structure.
extern void test__f_utf_string_tripless_append_all__returns_data_not(void **state);
/**
- * Test that the function correctly fails on invalid parameter.
+ * Test that the function works.
*
* @see f_utf_string_tripless_append_all()
*/
-extern void test__f_utf_string_tripless_append_all__parameter_checking(void **state);
+extern void test__f_utf_string_tripless_append_all__works(void **state);
#endif // _TEST__F_utf_tripless_append_all_h
projects / fll / commitdiff