void test_split() { int size = 0; char the_string[] = "fooasdbar"; char **ret_val; ret_val = pl_split(the_string, "asd", &size); assert_equal_str( "foo", ret_val[0], "test_split", "Test 1: The strings are not equal." ); assert_equal_str( "bar", ret_val[1], "test_split", "Test 2: The strings are not equal." ); assert_equal_int( 2, size, "test_split", "Test 3: Size is not correct." ); free(ret_val[0]); free(ret_val[1]); free(ret_val); }
void test_expandtabs() { char *ret_val; ret_val = pl_expandtabs("this is a\ttabbed\t\tstring", 4); assert_equal_str( "this is a tabbed string", ret_val, "test_expandtabs", "Test 1: Strings are not equal." ); free(ret_val); ret_val = pl_expandtabs("'\t'", 10); assert_equal_str( "' '", ret_val, "test_expandtabs", "Test 2: Strings are not equal." ); free(ret_val); ret_val = pl_expandtabs("asd\tdsa", 0); assert_equal_str( "asddsa", ret_val, "test_expandtabs", "Test 3: Strings are not equal." ); free(ret_val); }
void test_slice_both_negative() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, -13, -4); assert_equal_str( "eggs, and", ret_val, "test_slice_both_negative", "Test 1: The function did not return the correct substring." ); free(ret_val); ret_val = pl_slice(the_string, -5, -5); assert_equal_str( NULL, ret_val, "test_slice_both_negative", "Test 2: The function did not return the correct substring." ); ret_val = pl_slice(the_string, -5, -10); assert_equal_str( NULL, ret_val, "test_slice_both_negative", "Test 3: The function did not return the correct substring." ); }
void test_strcat_empty_params() { char *ret_val; ret_val = pl_cat(NULL, "asd"); assert_equal_str( NULL, ret_val, "test_strcat_empty_params", "Test 1: NULL not returned." ); ret_val = pl_cat("asd", NULL); assert_equal_str( NULL, ret_val, "test_strcat_empty_params", "Test 2: NULL not returned." ); ret_val = pl_cat(NULL, NULL); assert_equal_str( NULL, ret_val, "test_strcat_empty_params", "Test 3: NULL not returned." ); }
void test_translate() { char *ret_val; ret_val = pl_translate("read this short text", NULL, "aeiou"); assert_equal_str( "rd ths shrt txt", ret_val, "test_translate", "Test 1: Strings are not equal." ); free(ret_val); ret_val = pl_translate("read this short text", (unsigned char *) "aeiou", "xxxxx"); assert_equal_str( "rxxd thxs shxrt txxt", ret_val, "test_translate", "Test 2: Strings are not equal." ); free(ret_val); ret_val = pl_translate("read this short text", (unsigned char *) "zzzzz", "aeiou"); assert_equal_str( "read this short text", ret_val, "test_translate", "Test 3: Strings are not equal" ); free(ret_val); }
void test_slice_negative_offset() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, -3, 9); assert_equal_str( NULL, ret_val, "test_slice_negative_offset", "Test 1: The ret_val is not empty." ); ret_val = pl_slice(the_string, -1, 9); assert_equal_str( NULL, ret_val, "test_slice_negative_offset", "Test 2: The ret_val is not empty." ); ret_val = pl_slice(the_string, -9, 9); assert_equal_str( NULL, ret_val, "test_slice_negative_offset", "Test 3: The ret_val is not empty." ); ret_val = pl_slice(the_string, -1, 3); assert_equal_str( NULL, ret_val, "test_slice_negative_offset", "Test 4: The ret_val is not empty." ); ret_val = pl_slice(the_string, -4, 1); assert_equal_str( NULL, ret_val, "test_slice_negative_offset", "Test 5: The ret_val is not empty." ); }
void test_strip_empty_params() { char *ret_val; ret_val = pl_strip("", "a"); assert_equal_str( NULL, ret_val, "test_strip_empty_params", "Test 1: NULL not returned." ); ret_val = pl_strip(" asd ", ""); assert_equal_str( "asd", ret_val, "test_strip_empty_params", "Test 2: Strings not equal." ); free(ret_val); ret_val = pl_strip(" asd ", NULL); assert_equal_str( "asd", ret_val, "test_strip_empty_params", "Test 3: Strings not equal." ); free(ret_val); ret_val = pl_strip(NULL, NULL); assert_equal_str( NULL, ret_val, "test_strip_empty_params", "Test 4: NULL not returned" ); ret_val = pl_strip(NULL, "asd"); assert_equal_str( NULL, ret_val, "test_strip_empty_params", "Test 5: NULL not returned." ); }
void test_strip_with_chars() { char *ret_val; char str1[] = "aaabbbccc"; char str2[] = "bbbcccaaa"; char str3[] = "aaabbbcccaaa"; char str4[] = "adadbbbcccadad"; ret_val = pl_strip(str1, "a"); assert_equal_str( "bbbccc", ret_val, "test_strip_with_chars", "Test 1: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str2, "a"); assert_equal_str( "bbbccc", ret_val, "test_strip_with_chars", "Test 2: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str3, "a"); assert_equal_str( "bbbccc", ret_val, "test_strip_with_chars", "Test 3: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str4, "ad"); assert_equal_str( "bbbccc", ret_val, "test_strip_with_chars", "Test 4: Strings are not equal." ); free(ret_val); }
void test_strip_no_chars() { char the_string[] = " aaabbbccc"; char str2[] = "aaabbbccc "; char str3[] = " aaabbbccc "; char str4[] = "\n\r\t\v\f aaabbbccc \f\v\r\n\t"; char *ret_val; ret_val = pl_strip(the_string, NULL); assert_equal_str( "aaabbbccc", ret_val, "test_strip_no_chars", "Test 1: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str2, NULL); assert_equal_str( "aaabbbccc", ret_val, "test_strip_no_chars", "Test 2: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str3, NULL); assert_equal_str( "aaabbbccc", ret_val, "test_strip_no_chars", "Test 3: Strings are not equal." ); free(ret_val); ret_val = pl_strip(str4, NULL); assert_equal_str( "aaabbbccc", ret_val, "test_strip_no_chars", "Test 4: Strings are not equal." ); free(ret_val); }
void test_slice_negative_limit() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, 1, -3); assert_equal_str( "pam, eggs, and ", ret_val, "test_slice_negative_limit", "Test 1: The strings are not equal" ); free(ret_val); ret_val = pl_slice(the_string, 1, -10); assert_equal_str( "pam, egg", ret_val, "test_slice_negative_limit", "Test 2: The strings are not equal" ); free(ret_val); ret_val = pl_slice(the_string, 9, -10); assert_equal_str( NULL, ret_val, "test_slice_negative_limit", "Test 3: The strings are not equal" ); ret_val = pl_slice(the_string, 0, -5); assert_equal_str( "spam, eggs, an", ret_val, "test_slice_negative_limit", "Test 4: The strings are not equal" ); free(ret_val); }
void test_splitlines_keepends() { char **ret_val = NULL; int size = 0; ret_val = pl_splitlines("asd\ndsa\n\rqwe", 1, &size); assert_equal_str( "asd\n", ret_val[0], "test_splitlines_keepends", "Test 1: Strings not equal." ); assert_equal_str( "dsa\n", ret_val[1], "test_splitlines_keepends", "Test 2: Strings not equal." ); assert_equal_str( "\r", ret_val[2], "test_splitlines_keepends", "Test 3: Strings not equal." ); assert_equal_str( "qwe", ret_val[3], "test_splitlines_keepends", "Test 4: Strings not equal." ); assert_equal_int( 4, size, "test_splitlines_keepends", "Test 5: Size not right." ); free(ret_val[0]); free(ret_val[1]); free(ret_val[2]); free(ret_val[3]); free(ret_val); }
void test_splitlines() { char **ret_val = NULL; int size = 0; ret_val = pl_splitlines("asd\ndsa\n\rqwe", 0, &size); assert_equal_str( "asd", ret_val[0], "test_splitlines", "Test 1: Strings are not equal" ); assert_equal_str( "dsa", ret_val[1], "test_splitlines", "Test 2: Strings are not equal." ); assert_equal_str( "", ret_val[2], "test_splitlines", "Test 3: String is not empty." ); assert_equal_str( "qwe", ret_val[3], "test_splitlines", "Test 4: Strings are not equal." ); assert_equal_int( 4, size, "test_splitlines", "Test 5: Size not right;" ); free(ret_val[0]); free(ret_val[1]); free(ret_val[2]); free(ret_val[3]); free(ret_val); }
void test_split_empty_paras() { char **ret_val; int size = 0; ret_val = pl_split("", " ", &size); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_paras", "Test 1: NULL not returned." ); ret_val = pl_split(NULL, " ", &size); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_paras", "Test 2: NULL not returned" ); ret_val = pl_split("asd asd", "", &size); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_paras", "Test 3: NULL not returned." ); ret_val = pl_split("asd asd", NULL, &size); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_paras", "Test 4: NULL not returned." ); ret_val = pl_split("asd asd", " ", NULL); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_paras", "Test 5: NULL not returned." ); }
void test_slice_empty_string() { char *ret_val; ret_val = pl_slice("", 1, 3); assert_equal_str( NULL, ret_val, "test_slice_empty_string", "Test 1: NULL not returned." ); ret_val = pl_slice(NULL, 1, 3); assert_equal_str( NULL, ret_val, "test_slice_empty_string", "Test 2: NULL not returned." ); }
void test_db_prepare(void) { DB *db; DBStatement *stmt; const char *sql_tail; db = db_open("test.db"); db_prepare(db, "select * from memos;", &stmt, &sql_tail); assert_equal_str(sql_tail, ""); db_finalize(stmt); db_close(db); }
void test_strcpy_empty_paras() { char *ret_val; ret_val = pl_cpy(NULL, NULL); assert_equal_str( NULL, ret_val, "test_strcpy_empty_paras", "Test 2: NULL not returned." ); }
void test_split_single_delim() { int size = 0; char the_string[] = "abc def ghi"; char **ret_val; ret_val = pl_split(the_string, " ", &size); assert_equal_str( "abc", ret_val[0], "test_split_single_delim", "Test 1: Strings not equal." ); assert_equal_str( "def", ret_val[1], "test_split_single_delim", "Test 2: Strings not equal." ); assert_equal_str( "ghi", ret_val[2], "test_split_single_delim", "Test 3: Strings not equal." ); assert_equal_int( 3, size, "test_split_single_delim", "Test 4: Size of the returned array is not right." ); free(ret_val[0]); free(ret_val[1]); free(ret_val[2]); free(ret_val); }
void test_split_multiple_delims() { int size = 0; char the_string[] = "fooasdbarasdmagic"; char **ret_val; ret_val = pl_split(the_string, "asd", &size); assert_equal_str( "foo", ret_val[0], "test_split_multiple_delims", "Test 1: Strings are not equal." ); assert_equal_str( "bar", ret_val[1], "test_split_multiple_delims", "Test 2: Strings are not equal." ); assert_equal_str( "magic", ret_val[2], "test_split_multiple_delims", "Test 3: Strings are not equal" ); assert_equal_int( 3, size, "test_split_multiple_delims", "Test 4: Size is not correct." ); free(ret_val[0]); free(ret_val[1]); free(ret_val[2]); free(ret_val); }
void test_slice_equal_offlim() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, 3, 3); assert_equal_str( NULL, ret_val, "test_slice_equal_offlim", "The strings are not equal." ); }
void test_slice_offset_oor() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, 99, 199); assert_equal_str( NULL, ret_val, "test_slice_offset_oor", "The ret_val was not NULL" ); }
void test_slice_positive_sub_str() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_slice(the_string, 3, 9); assert_equal_str( "m, egg", ret_val, "test_slice_positive_sub_str", "The substring is not equal to the sliced string." ); free(ret_val); }
void test_strcpy_no_alloc() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = pl_cpy(the_string, NULL); assert_equal_str( "spam, eggs, and ham", ret_val, "test_strcpy_no_alloc", "The strings are not equal." ); free(ret_val); }
void test_strcat_empty_source() { char empty[5] = {0}; char bar[] = "bar"; char *ret_val; ret_val = pl_cat(empty, bar); assert_equal_str( "bar", ret_val, "test_strcat_empty_source", "The strings are not equal." ); free(ret_val); }
void test_strcat_empty_destination() { char empty[5] = {0}; char foo[] = "foo"; char *ret_val; ret_val = pl_cat(foo, empty); assert_equal_str( "foo", ret_val, "test_strcat_empty_destination", "The strings are not equal." ); free(ret_val); }
void test_strcat() { char foo[] = "foo"; char bar[] = "bar"; char *ret_val; ret_val = pl_cat(foo, bar); assert_equal_str( "foobar", ret_val, "test_strcat", "The strings are not equal." ); free(ret_val); }
void test_strcpy_pre_alloc() { char the_string[] = "spam, eggs, and ham"; char *ret_val; ret_val = (char *) calloc(strlen(the_string) + 1, sizeof(char)); ret_val = pl_cpy(the_string, ret_val); assert_equal_str( "spam, eggs, and ham", ret_val, "test_strcpy_pre_alloc", "The strings are not equal." ); free(ret_val); }
void test_strcpy_not_empty() { char the_string[] = "spam, eggs, and ham"; char *ret_val, tmp[100]; strcpy(tmp, "foobar"); ret_val = pl_cpy(the_string, NULL); assert_equal_str( "spam, eggs, and ham", ret_val, "test_strcpy_not_empty", "The strings are not equal" ); free(ret_val); }
void test_split_delim_not_found() { int size = 0; char the_string[] = "fooasdbarasdmagic"; char **ret_val; ret_val = pl_split(the_string, "x", &size); assert_equal_str( NULL, (char *) ret_val, "test_split_delim_not_found", "Test 1: NULL not returned." ); assert_equal_int( 0, size, "test_split_delim_not_found", "Test 2: Size is not correct." ); }
void test_split_empty_delim() { int size = 0; char the_string[] = "fooasdbarasdmagic"; char **ret_val; ret_val = pl_split(the_string, "", &size); assert_equal_str( NULL, (char *) ret_val, "test_split_empty_delim", "Test 1: NULL not returned." ); assert_equal_int( 0, size, "test_split_empty_delim", "Test 2: Size is not right." ); }
void test_db(void) { DB *mydb; DBResults *results; char *errormsg; mydb = db_open("test.db"); results = db_get_table(mydb, "select * from memos;", &errormsg); assert_equal_str(db_results_table_lookup(results, 0, 0), "Hello"); assert_equal_str(db_results_table_lookup(results, 0, 1), "World"); assert_equal_str(db_results_table_lookup(results, 1, 0), "Yes"); assert_equal_str(db_results_table_lookup(results, 1, 1), "No"); assert_equal_str(db_results_column_name(results, 0), "subject"); assert_equal_str(db_results_column_name(results, 1), "body"); db_results_free(results); db_close(mydb); }