static void test_textfile_read_line_generic(const char *filename,
enum RFtext_encoding encoding,
enum RFendianess endianess)
{
struct RFtextfile f;
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_fname, filename, strlen(filename)));
ck_assert(rf_textfile_init(&f, &g_fname, RF_FILE_READ, endianess,
encoding, RF_EOL_LF));
/* 1st line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(encoding, endianess, false, line_scenario1));
/* 2nd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(encoding, endianess, false, line_scenario2));
/* 3rd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(encoding, endianess, false, line_scenario3));
/* EOF */
ck_assert(RE_FILE_EOF == rf_textfile_read_line(&f, &g_buff));
rf_textfile_deinit(&f);
}
}END_TEST
START_TEST(test_stringx_reset) {
struct RFstringx s;
static const struct RFstring sub1 = RF_STRING_STATIC_INIT("に");
ck_assert(
rf_stringx_init(
&s,
"中国共産党総書記に習近平氏 新指導部の７人発表"
)
);
/* resetting an unmoved string has no effect */
rf_stringx_reset(&s);
ck_assert_rf_str_eq_cstr(
&s,
"中国共産党総書記に習近平氏 新指導部の７人発表"
);
/* move and reset */
ck_assert(RF_FAILURE != rf_stringx_move_after(&s, &sub1, NULL, 0));
ck_assert_rf_str_eq_cstr(&s, "習近平氏 新指導部の７人発表");
rf_stringx_reset(&s);
ck_assert_rf_str_eq_cstr(
&s,
"中国共産党総書記に習近平氏 新指導部の７人発表"
);
rf_stringx_deinit(&s);
}END_TEST
}END_TEST
START_TEST(test_textfile_insert_before) {
struct RFtextfile f;
static const char *s;
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_fname, CLIB_TESTS_PATH"temp_file",
strlen(CLIB_TESTS_PATH"temp_file")));
ck_assert(rf_textfile_init(&f, &g_fname, RF_FILE_NEW,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
/* write line 1 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario1);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* write line 3 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario3);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* now insert line before 1st */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario2);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_insert(&f, 1, &g_buff, false));
/* go to the starting position and switch to reading */
ck_assert(RF_SUCCESS == rf_textfile_go_to_line(&f, 1));
ck_assert(rf_textfile_set_mode(&f, RF_FILE_READ));
/* read 1st line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario2));
/* read 2nd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario1));
/* read 3rd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario3));
/* check for empty line and EOF */
ck_assert(RE_FILE_EOF == rf_textfile_read_line(&f, &g_buff));
rf_textfile_deinit(&f);
ck_assert(rf_system_delete_file(&g_fname));
}END_TEST
}END_TEST
START_TEST(test_textfile_replace) {
struct RFtextfile f;
static const char *s;
static struct RFstring str = RF_STRING_STATIC_INIT("Line Replacement");
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_fname, CLIB_TESTS_PATH"temp_file",
strlen(CLIB_TESTS_PATH"temp_file")));
ck_assert(rf_textfile_init(&f, &g_fname, RF_FILE_NEW,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
/* write line 1 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario1);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* write line 2 */
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, SECOND_LINE_UTF8"\n",
strlen(SECOND_LINE_UTF8"\n")));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* write line 3 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario3);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, THIRD_LINE_UTF8"\n",
strlen(THIRD_LINE_UTF8"\n")));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* replace the 2nd line */
ck_assert(rf_textfile_replace(&f, 2, &str));
/* go to the starting position and switch to reading */
ck_assert(RF_SUCCESS == rf_textfile_go_to_line(&f, 1));
ck_assert(rf_textfile_set_mode(&f, RF_FILE_READ));
/* read 1st line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario1));
/* read 2nd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert(rf_string_equal(&str, RF_STRX2STR(&g_buff)));
/* read 3rd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(&g_buff, THIRD_LINE_UTF8);
/* check for empty line and EOF */
ck_assert(RE_FILE_EOF == rf_textfile_read_line(&f, &g_buff));
ck_assert(rf_system_delete_file(&g_fname));
rf_textfile_deinit(&f);
}END_TEST
}END_TEST
START_TEST(test_textfile_copy) {
struct RFtextfile f;
struct RFtextfile copy_f;
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_fname, CLIB_TESTS_PATH"utf8stringfile",
strlen(CLIB_TESTS_PATH"utf8stringfile")));
ck_assert(rf_textfile_init(&f, &g_fname, RF_FILE_READ,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
/* 1st line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario1));
/* make a copy */
ck_assert(rf_textfile_copy_in(©_f, &f));
/* 2nd line from copy */
ck_assert(RF_SUCCESS == rf_textfile_read_line(©_f, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario2));
rf_textfile_deinit(&f);
rf_textfile_deinit(©_f);
}END_TEST
} END_TEST
START_TEST (test_type_to_str) {
struct type *t_u32 = testsupport_analyzer_type_create_simple_elementary(ELEMENTARY_TYPE_UINT_32);
struct type *t_f64 = testsupport_analyzer_type_create_simple_elementary(ELEMENTARY_TYPE_FLOAT_64);
struct type *t_string = testsupport_analyzer_type_create_simple_elementary(ELEMENTARY_TYPE_STRING);
struct type *t_prod_1 = testsupport_analyzer_type_create_operator(TYPEOP_PRODUCT,
t_u32,
t_f64);
struct type *t_sum_1 = testsupport_analyzer_type_create_operator(TYPEOP_SUM,
t_f64,
t_string);
static const struct RFstring id_person = RF_STRING_STATIC_INIT("person");
struct type *t_defined_1 = testsupport_analyzer_type_create_defined(&id_person,
t_sum_1);
struct RFstring *ts;
RFS_PUSH();
ck_assert((ts = type_str(t_u32, TSTR_DEFAULT)));
ck_assert_rf_str_eq_cstr(ts, "u32");
ck_assert((ts = type_str(t_prod_1, TSTR_DEFAULT)));
ck_assert_rf_str_eq_cstr(ts, "u32,f64");
ck_assert((ts = type_str(t_defined_1, TSTR_DEFAULT)));
ck_assert_rf_str_eq_cstr(ts, "person");
RFS_POP();
} END_TEST
}END_TEST
START_TEST(test_stringx_move_after_pair) {
struct RFstringx s;
struct RFstring res_str_good;
struct RFstring res_str_bad;
struct RFstring dependent_s;
static const struct RFstring sub1 = RF_STRING_STATIC_INIT("「");
static const struct RFstring sub2 = RF_STRING_STATIC_INIT("」");
static const struct RFstring sub3 = RF_STRING_STATIC_INIT("eleos");
static const struct RFstring sub4 = RF_STRING_STATIC_INIT("notthere");
ck_assert(
rf_stringx_init(
&s,
"これがMoveAfterPairのテストですね！「Δεν θα επιστραφω εγω"
"」 Γεμιζουμε το στρινγκ "
"με διαφορα 「ブラケットの中のテ"
"キストは結果になる」Let's see if the function will work "
"as expected."
)
);
ck_assert(
rf_stringx_move_after_pair(&s, &sub1, &sub2, &res_str_good, 0, 2)
);
ck_assert_rf_str_eq_cstr(
&s, "Let's see if the function will work as expected."
);
ck_assert_rf_str_eq_cstr(
&res_str_good, "ブラケットの中のテキストは結果になる"
);
/* dependent string */
rf_stringx_reset(&s);
ck_assert(
rf_stringx_move_after_pair(&s, &sub1, &sub2,
&dependent_s, RF_STRING_DEPENDENT, 2)
);
ck_assert_rf_str_eq_cstr(
&s, "Let's see if the function will work as expected."
);
ck_assert_rf_str_eq_cstr(
&dependent_s, "ブラケットの中のテキストは結果になる"
);
/* non existing substrings */
ck_assert(!rf_stringx_move_after_pair(&s, &sub3, &sub4, &res_str_bad, 0, 2));
rf_stringx_deinit(&s);
rf_string_deinit(&res_str_good);
rf_string_deinit(&dependent_s);
}END_TEST
}END_TEST
START_TEST(test_textfile_read_lines) {
struct RFtextfile f;
static const struct RFstring fname = RF_STRING_STATIC_INIT(
CLIB_TESTS_PATH"utf8stringfile"
);
uint32_t buff_arr[64];
struct RFarray line_arr = RF_ARRAY_SHALLOW_INIT(buff_arr);
ck_assert(rf_textfile_init(&f, &fname, RF_FILE_READ,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
rf_stringx_reset(&g_buff);
/* read all lines (3 + 1 empty line) */
ck_assert_int_eq(4, rf_textfile_read_lines(&f, 0, &g_buff, &line_arr));
ck_assert_rf_str_eq_cstr(&g_buff,
FIRST_LINE_UTF8"\n"
SECOND_LINE_UTF8"\n"
THIRD_LINE_UTF8"\n\n"
);
ck_assert_int_eq(rf_array_at_unsafe(&line_arr, 0, uint32_t), 0);
ck_assert_int_eq(rf_array_at_unsafe(&line_arr, 1, uint32_t), 11);
ck_assert_int_eq(rf_array_at_unsafe(&line_arr, 2, uint32_t), 366);
ck_assert_int_eq(rf_array_at_unsafe(&line_arr, 3, uint32_t), 1166);
ck_assert(RF_SUCCESS == rf_textfile_go_to_line(&f, 1));
/* read 3 lines */
ck_assert(3 == rf_textfile_read_lines(&f, 3, &g_buff, 0));
ck_assert_rf_str_eq_cstr(&g_buff,
FIRST_LINE_UTF8"\n"
SECOND_LINE_UTF8"\n"
THIRD_LINE_UTF8"\n"
);
ck_assert(RF_SUCCESS == rf_textfile_go_to_line(&f, 1));
/* read 2 lines */
ck_assert(2 == rf_textfile_read_lines(&f, 2, &g_buff, 0));
ck_assert_rf_str_eq_cstr(&g_buff,
FIRST_LINE_UTF8"\n"
SECOND_LINE_UTF8"\n"
);
ck_assert(RF_SUCCESS == rf_textfile_go_to_line(&f, 1));
/* read 1 line */
ck_assert(1 == rf_textfile_read_lines(&f, 1, &g_buff, 0));
ck_assert_rf_str_eq_cstr(&g_buff, FIRST_LINE_UTF8"\n");
rf_textfile_deinit(&f);
}END_TEST
} END_TEST
START_TEST (test_type_op_create_str) {
struct type *t_u32 = testsupport_analyzer_type_create_simple_elementary(ELEMENTARY_TYPE_UINT_32);
struct type *t_f64 = testsupport_analyzer_type_create_simple_elementary(ELEMENTARY_TYPE_FLOAT_64);
RFS_PUSH();
ck_assert_rf_str_eq_cstr(type_op_create_str(t_u32, t_f64, TYPEOP_PRODUCT), "u32,f64");
ck_assert_rf_str_eq_cstr(type_op_create_str(t_u32, t_f64, TYPEOP_SUM), "u32|f64");
ck_assert_rf_str_eq_cstr(type_op_create_str(t_u32, t_f64, TYPEOP_IMPLICATION), "u32->f64");
RFS_POP();
} END_TEST
}END_TEST
START_TEST(test_stringx_move_to_index) {
struct RFstringx s;
unsigned int pr_index;
ck_assert(
rf_stringx_init(
&s,
"Με την κεντρική εκδήλωση, μετά τις 2 το "
"μεσημέρι, και την "
"πορεία προς την αμερικανική πρεσβεία, "
"περίπου μία ώρα "
"αργότερα, κορυφώνονται το Σάββατο οι "
"εκδηλώσεις για την "
"39η επέτειο από την Εξέγερση του "
"Πολυτεχνείου. Λόγω των "
"εκδηλώσεων, θα ισχύσουν έκτακτες "
"κυκλοφοριακές ρυθμίσεις "
"έως και το πρωί της Κυριακής."
)
);
pr_index = s.bIndex;
rf_stringx_move_forward(&s, 96);
ck_assert_rf_str_eq_cstr(
&s,
"περίπου μία ώρα αργότερα, κορυφώνονται το "
"Σάββατο οι "
"εκδηλώσεις για την 39η επέτειο από την Εξέγερση "
"του Πολυτεχνείου. Λόγω των εκδηλώσεων, θα "
"ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και το πρωί "
"της Κυριακής."
);
rf_stringx_move_to_index(&s, pr_index);
ck_assert_rf_str_eq_cstr(
&s,
"Με την κεντρική εκδήλωση, μετά τις 2 το "
"μεσημέρι, και την "
"πορεία προς την αμερικανική πρεσβεία, "
"περίπου μία ώρα "
"αργότερα, κορυφώνονται το Σάββατο οι "
"εκδηλώσεις για την "
"39η επέτειο από την Εξέγερση του "
"Πολυτεχνείου. Λόγω των "
"εκδηλώσεων, θα ισχύσουν έκτακτες "
"κυκλοφοριακές ρυθμίσεις "
"έως και το πρωί της Κυριακής."
);
rf_stringx_deinit(&s);
}END_TEST
} END_TEST
START_TEST (test_RFS_same_ptr) {
struct RFstring *s1;
RFS_PUSH();
s1 = RFS("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
ck_assert_rf_str_eq_cstr(s1, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
s1 = RFS(RFS_PF "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ",
RFS_PA(s1));
ck_assert_rf_str_eq_cstr(s1,
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
RFS_POP();
} END_TEST
} END_TEST
START_TEST (test_RFS_realloc_vararg_at_second_use) {
struct RFstring *s1;
struct RFstring *s2;
RFS_PUSH();
s1 = RFS("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz%d%d", 23, 24);
ck_assert_rf_str_eq_cstr(s1, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz2324");
RFS_PUSH();
s2 = RFS("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ%s%d", "eleos", 124);
ck_assert_rf_str_eq_cstr(s1, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz2324");
ck_assert_rf_str_eq_cstr(s2, "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZeleos124");
RFS_POP();
RFS_POP();
} END_TEST
}END_TEST
START_TEST(test_stringx_move_forward) {
struct RFstringx s;
struct RFstringx s2;
ck_assert(
rf_stringx_init(
&s,
"Με την κεντρική εκδήλωση, μετά τις 2 το "
"μεσημέρι, και την "
"πορεία προς την αμερικανική πρεσβεία, "
"περίπου μία ώρα "
"αργότερα, κορυφώνονται το Σάββατο οι "
"εκδηλώσεις για την "
"39η επέτειο από την Εξέγερση του "
"Πολυτεχνείου. Λόγω των "
"εκδηλώσεων, θα ισχύσουν έκτακτες "
"κυκλοφοριακές ρυθμίσεις "
"έως και το πρωί της Κυριακής."
)
);
rf_stringx_move_forward(&s, 96);
ck_assert_rf_str_eq_cstr(
&s,
"περίπου μία ώρα αργότερα, κορυφώνονται το "
"Σάββατο οι "
"εκδηλώσεις για την 39η επέτειο από την Εξέγερση "
"του Πολυτεχνείου. Λόγω των εκδηλώσεων, θα "
"ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και το πρωί "
"της Κυριακής."
);
ck_assert(
rf_stringx_init(&s2, "中国共産党総書記に習近平氏 新指導部の７人発表")
);
rf_stringx_move_forward(&s2, 3);
ck_assert_rf_str_eq_cstr(&s2, "産党総書記に習近平氏 新指導部の７人発表");
/* go forward more than the length */
rf_stringx_move_forward(&s2, 999);
ck_assert_rf_str_eq_cstr(&s2, "");
rf_stringx_deinit(&s);
rf_stringx_deinit(&s2);
}END_TEST
static void test_RFS_in_recursive_functions()
{
RFS_PUSH();
struct RFstring *s1;
s1 = get_str_rec(NULL, 0, true);
ck_assert_rf_str_eq_cstr(
s1,
"0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
RFS_POP();
RFS_PUSH();
struct RFstring *s2;
s2 = get_str_rec(NULL, 1, true);
ck_assert_rf_str_eq_cstr(
s2,
"1abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
RFS_POP();
}
static void test_RFS_in_recursive_functions_with_local()
{
RFS_PUSH();
struct RFstring *s1;
s1 = get_str_rec_with_local(NULL, 0);
ck_assert_rf_str_eq_cstr(
s1,
"pre0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
RFS_POP();
RFS_PUSH();
struct RFstring *s2;
s2 = get_str_rec_with_local(NULL, 1);
ck_assert_rf_str_eq_cstr(
s2,
"pre0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre1abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
);
RFS_POP();
RFS_PUSH();
struct RFstring *s3;
s3 = get_str_rec_with_local(NULL, 2);
ck_assert_rf_str_eq_cstr(
s3,
"pre0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre1abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre2abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
);
RFS_POP();
RFS_PUSH();
struct RFstring *s4;
s4 = get_str_rec_with_local(NULL, 3);
ck_assert_rf_str_eq_cstr(
s4,
"pre0abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre1abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre2abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"pre3abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
);
RFS_POP();
}
} END_TEST
START_TEST (test_RFS_NT) {
struct RFstring *s1 = RFS_NT("a string");
struct RFstring *s2 = RFS_NT("a string %s %d", "with", 123);
ck_assert_rf_str_eq_cstr(s1, "a string");
ck_assert(rf_string_data(s1)[rf_string_length_bytes(s1)] == '\0');
ck_assert_rf_str_eq_cstr(s2, "a string with 123");
ck_assert(rf_string_data(s2)[rf_string_length_bytes(s2)] == '\0');
struct RFstring *s3 = RFS_NT_OR_DIE("a string");
struct RFstring *s4 = RFS_NT("a string %s %d", "with", 123);
ck_assert_rf_str_eq_cstr(s3, "a string");
ck_assert(rf_string_data(s3)[rf_string_length_bytes(s3)] == '\0');
ck_assert_rf_str_eq_cstr(s4, "a string with 123");
ck_assert(rf_string_data(s4)[rf_string_length_bytes(s4)] == '\0');
// test that subsequent allocations don't overwite the null terminating
// character
ck_assert(rf_string_data(s1)[rf_string_length_bytes(s1)] == '\0');
ck_assert(rf_string_data(s2)[rf_string_length_bytes(s2)] == '\0');
ck_assert(rf_string_data(s3)[rf_string_length_bytes(s3)] == '\0');
ck_assert(rf_string_data(s4)[rf_string_length_bytes(s4)] == '\0');
} END_TEST
} END_TEST
START_TEST (test_RFS_realloc_at_first_use) {
struct RFstring *s1;
struct RFstring *s2;
RFS_PUSH();
s1 = RFS(
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
ck_assert_rf_str_eq_cstr(
s1,
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
RFS_PUSH();
s2 = RFS("ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
ck_assert_rf_str_eq_cstr(
s1,
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz");
ck_assert_rf_str_eq_cstr(s2, "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ");
RFS_POP();
RFS_POP();
} END_TEST
} END_TEST
START_TEST(test_acc_ws_none_empty) {
struct inpfile *f;
struct front_ctx *front;
struct inpoffset *off;
struct RFstringx *str;
front = front_testdriver_new_main_source(rf_string_empty_get());
f = front->file;
ck_assert_msg(f, "Failed to assign string to file ");
inpfile_acc_ws(f);
off = inpfile_offset(f);
ck_assert_inpoffset_eq(off, 0, 0, 0);
str = inpfile_str(f);
ck_assert_rf_str_eq_cstr(str, "");
} END_TEST
}END_TEST
START_TEST(test_stringx_move_end) {
struct RFstringx s;
ck_assert(
rf_stringx_init(
&s,
"中国共産党総書記に習近平氏 新指導部の７人発表")
);
rf_stringx_move_end(&s);
ck_assert_rf_str_eq_cstr(&s, "");
ck_assert(s.bIndex == strlen(
"中国共産党総書記に習近平氏 新指導部の７人発表")
);
rf_stringx_deinit(&s);
}END_TEST
} END_TEST
START_TEST(test_acc_ws_full) {
struct inpfile *f;
struct front_ctx *front;
struct inpoffset *off;
struct RFstringx *str;
static const struct RFstring s = RF_STRING_STATIC_INIT(" \n \r \t \n \n ");
front = front_testdriver_new_main_source(&s);
f = front->file;
ck_assert_msg(f, "Failed to assign string to file ");
inpfile_acc_ws(f);
off = inpfile_offset(f);
ck_assert_inpoffset_eq(off, 12, 12, 3);
str = inpfile_str(f);
ck_assert_rf_str_eq_cstr(str, "");
} END_TEST
}END_TEST
/* Textfile Writting tests -- START */
START_TEST(test_textfile_write) {
struct RFtextfile f;
struct RFtextfile rf;
static const char *s;
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_fname, CLIB_TESTS_PATH"temp_file",
strlen(CLIB_TESTS_PATH"temp_file")));
ck_assert(rf_textfile_init(&f, &g_fname, RF_FILE_NEW,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
/* write line 1 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario1);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* write line 2 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario2);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
/* write line 3 */
s = get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, true, line_scenario3);
ck_assert(rf_stringx_assign_unsafe_nnt(
&g_buff, s,
strlen(s)));
ck_assert(rf_textfile_write(&f, RF_STRX2STR(&g_buff)));
rf_textfile_deinit(&f);
/* reading */
ck_assert(rf_textfile_init(&rf, &g_fname, RF_FILE_READ,
RF_ENDIANESS_UNKNOWN,
RF_UTF8, RF_EOL_LF));
/* read 1st line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&rf, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario1));
/* read 2nd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&rf, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario2));
/* read 3rd line */
ck_assert(RF_SUCCESS == rf_textfile_read_line(&rf, &g_buff));
ck_assert_rf_str_eq_cstr(
&g_buff,
get_line(RF_UTF8, RF_ENDIANESS_UNKNOWN, false, line_scenario3));
/* check for empty line and EOF */
ck_assert(RE_FILE_EOF == rf_textfile_read_line(&rf, &g_buff));
ck_assert(rf_system_delete_file(&g_fname));
rf_textfile_deinit(&rf);
}END_TEST
}END_TEST
START_TEST(test_stringx_skip_chars) {
struct RFstringx s;
unsigned int bytes;
unsigned int line_count;
static const struct RFstring s1 = RF_STRING_STATIC_INIT(" \t something");
static const struct RFstring chars1 = RF_STRING_STATIC_INIT(" \t");
static const struct RFstring s2 = RF_STRING_STATIC_INIT(
" ブ ブ ラ something_else");
static const struct RFstring chars2 = RF_STRING_STATIC_INIT(" ブラ");
static const struct RFstring s3 = RF_STRING_STATIC_INIT(
" \n \n \t foo");
static const struct RFstring chars3 = RF_STRING_STATIC_INIT(" \t\n");
static const struct RFstring s4 = RF_STRING_STATIC_INIT(
"not skipping \t \n \n");
ck_assert(rf_stringx_init_buff(&s, 1024, ""));
ck_assert(rf_stringx_assign(&s, &s1));
ck_assert_int_eq(6, rf_stringx_skip_chars(&s, &chars1, 0, &bytes, 0));
ck_assert_int_eq(6, bytes);
ck_assert_rf_str_eq_cstr(&s, "something");
ck_assert(rf_stringx_assign(&s, &s2));
ck_assert_int_eq(7, rf_stringx_skip_chars(&s, &chars2, 0, &bytes, 0));
ck_assert_int_eq(13, bytes);
ck_assert_rf_str_eq_cstr(&s, "something_else");
ck_assert(rf_stringx_assign(&s, &s3));
ck_assert_int_eq(8, rf_stringx_skip_chars(&s, &chars3, 0,
&bytes, &line_count));
ck_assert_int_eq(8, bytes);
ck_assert_int_eq(2, line_count);
ck_assert_rf_str_eq_cstr(&s, "foo");
ck_assert(rf_stringx_assign(&s, &s3));
ck_assert_int_eq(3, rf_stringx_skip_chars(&s, &chars3,
rf_string_data(&s) + 2,
&bytes, &line_count));
ck_assert_int_eq(3, bytes);
ck_assert_int_eq(1, line_count);
ck_assert_rf_str_eq_cstr(&s," \n \t foo");
ck_assert(rf_stringx_assign(&s, &s3));
ck_assert_int_eq(1, rf_stringx_skip_chars(&s, &chars3,
rf_string_data(&s),
&bytes, &line_count));
ck_assert_int_eq(1, bytes);
ck_assert_int_eq(0, line_count);
ck_assert_rf_str_eq_cstr(&s,"\n \n \t foo");
ck_assert(rf_stringx_assign(&s, &s4));
ck_assert_int_eq(0, rf_stringx_skip_chars(&s, &chars3,
0, &bytes, &line_count));
ck_assert_int_eq(0, bytes);
ck_assert_int_eq(0, line_count);
rf_stringx_deinit(&s);
}END_TEST
}END_TEST
START_TEST(test_stringx_move_afterv) {
unsigned int saved_index;
struct RFstringx s;
struct RFstringx str_buff;
struct RFstring dependent_s;
static const struct RFstring sub1 = RF_STRING_STATIC_INIT(",");
static const struct RFstring sub2 = RF_STRING_STATIC_INIT("39");
ck_assert(rf_stringx_init_buff(&str_buff, 1024, ""));
ck_assert(
rf_stringx_init(
&s,
"Με την κεντρική εκδήλωση, μετά τις 2 το "
"μεσημέρι, και την "
"πορεία προς την αμερικανική πρεσβεία, "
"περίπου μία ώρα "
"αργότερα, κορυφώνονται το Σάββατο οι "
"εκδηλώσεις για την "
"39η επέτειο από την Εξέγερση του "
"Πολυτεχνείου. Λόγω των "
"εκδηλώσεων, θα ισχύσουν έκτακτες "
"κυκλοφοριακές ρυθμίσεις "
"έως και το πρωί της Κυριακής."
)
);
rf_stringx_move_forward(&s, 96);
ck_assert_rf_str_eq_cstr(
&s,
"περίπου μία ώρα αργότερα, κορυφώνονται το "
"Σάββατο οι "
"εκδηλώσεις για την 39η επέτειο από την Εξέγερση "
"του Πολυτεχνείου. Λόγω των εκδηλώσεων, θα "
"ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και το πρωί "
"της Κυριακής."
);
rf_stringx_move_back(&s, 46);
ck_assert_rf_str_eq_cstr(
&s,
"και την πορεία προς την αμερικανική πρεσβεία, "
"περίπου"
" μία ώρα αργότερα, κορυφώνονται το Σάββατο οι "
"εκδηλώσεις για την 39η επέτειο από την Εξέγερση "
"του Πολυτεχνείου. Λόγω των εκδηλώσεων, θα "
"ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και "
"το πρωί "
"της Κυριακής."
);
saved_index = s.bIndex;
ck_assert(rf_stringx_move_afterv(&s, &str_buff, 0, 2, &sub1, &sub2));
ck_assert_rf_str_eq_cstr(
&s,
" περίπου μία ώρα αργότερα, κορυφώνονται "
"το Σάββατο οι"
" εκδηλώσεις για την 39η επέτειο από "
"την Εξέγερση του "
"Πολυτεχνείου. Λόγω των εκδηλώσεων, θα ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και "
"το πρωί της Κυριακής."
);
ck_assert_rf_str_eq_cstr(
&str_buff,
"και την πορεία προς την αμερικανική πρεσβεία"
);
/* dependent string */
rf_stringx_move_to_index(&s, saved_index);
ck_assert(rf_stringx_move_afterv(&s, &dependent_s,
RF_STRING_DEPENDENT, 2, &sub1, &sub2));
ck_assert_rf_str_eq_cstr(
&s,
" περίπου μία ώρα αργότερα, κορυφώνονται "
"το Σάββατο οι"
" εκδηλώσεις για την 39η επέτειο από "
"την Εξέγερση του "
"Πολυτεχνείου. Λόγω των εκδηλώσεων, θα ισχύσουν "
"έκτακτες κυκλοφοριακές ρυθμίσεις έως και "
"το πρωί της Κυριακής."
);
ck_assert_rf_str_eq_cstr(
&dependent_s,
"και την πορεία προς την αμερικανική πρεσβεία"
);
rf_stringx_deinit(&s);
rf_stringx_deinit(&str_buff);
}END_TEST
