change replace func at all

diff --git a/src/main.c b/src/main.c
index 6516cd030011c3fd8b750f2391771036a2f5bbb1..11f85736364f7088b420982ba2150a5e1c6cfeb9 100644 (file)
--- a/src/main.c
+++ b/src/main.c
@@ -41,40 +41,24 @@ void rename_file(const char* input, const char* output)
 
 void rename_files(const char* dir_path, rename_ptr renamefunc)
 {
-       char* output = malloc(STR_MAX_LENGTH);
-       if (output == NULL)
-               return;
-
-       char* dirname = malloc(STR_MAX_LENGTH);
-       if (dirname == NULL) {
-               free(output);
-               output = NULL;
-               return;
-       }
-
-       memset(output, 0, STR_MAX_LENGTH);
-       memset(dirname, 0, STR_MAX_LENGTH);
        glob_t* files = get_files(dir_path);
        for (size_t i = 0; i < files->gl_pathc; i++) {
-               renamefunc(files->gl_pathv[i], output);
+               char* output = strdup(files->gl_pathv[i]);
+               output = renamefunc(&output);
                rename_file(files->gl_pathv[i], output);
 
                if (is_dir(output)) {
-                       escape(output, dirname);
-                       rename_files(dirname, renamefunc);
-                       memset(dirname, 0, STR_MAX_LENGTH);
+                       output = escape(&output);
+                       rename_files(output, renamefunc);
                }
 
-               memset(output, 0, STR_MAX_LENGTH);
+               free(output);
+               output = NULL;
        }
 
        globfree(files);
        free(files);
        files = NULL;
-       free(dirname);
-       dirname = NULL;
-       free(output);
-       output = NULL;
 }
 
 int main(int argc, char* argv[])

diff --git a/src/rename.c b/src/rename.c
index 4a00501e8bc9d9dac37cc29019203a3e3a397b34..e92dabe92b7f29d7ecbe195846d041e73b6c2138 100644 (file)
--- a/src/rename.c
+++ b/src/rename.c
@@ -4,6 +4,18 @@
 
 #include "rename.h"
 
+char* strdup(const char* str)
+{
+       size_t len = strlen(str) + 1;
+       char* value =  malloc(len);
+       if (value == NULL)
+               return NULL;
+
+       strncpy(value, str, len);
+
+       return value;
+}
+
 char* replace(char** src, const char* pattern, const char* replace_str)
 {
        const size_t len = strlen(*src);
@@ -39,16 +51,9 @@ char* replace(char** src, const char* pattern, const char* replace_str)
        return output;
 }
 
-void escape(const char* src, char* dst)
+char* escape(char** src)
 {
-       size_t len = strlen(src) + 1;
-       char* out = malloc(len);
-       if (out == NULL)
-               return;
-
-       memcpy(out, src, len);
-
-       out = replace(&out, " ", "\\ ");
+       char* out = replace(src, " ", "\\ ");
        out = replace(&out, "(", "\\(");
        out = replace(&out, ")", "\\)");
        out = replace(&out, "{", "\\{");
@@ -56,48 +61,32 @@ void escape(const char* src, char* dst)
        out = replace(&out, "[", "\\[");
        out = replace(&out, "]", "\\]");
 
-       memcpy(dst, out, strlen(out) + 1);
-       free(out);
-       out = NULL;
+       return out;
 }
 
-void rename_point(const char* src, char* dst)
+char* rename_point(char** src)
 {
-       size_t len = strlen(src) + 1;
-       char* out = malloc(len);
-       if (out == NULL)
-               return;
-
-       memcpy(out, src, len);
-
-       rename_string(src, out);
+       char* out = rename_string(src);
        out = replace(&out, ".", "");
 
-       memcpy(dst, out, strlen(out) + 1);
-       free(out);
-       out = NULL;
+       return out;
 }
 
-void rename_lower(const char* src, char* dst)
+char* rename_lower(char** src)
 {
-       rename_string(src, dst);
-       size_t length = strlen(dst);
+       char* out = rename_string(src);
+       size_t length = strlen(out);
        for (size_t i = 0; i < length; i++) {
-               if (dst[i] >= A && dst[i] <= Z)
-                       dst[i] += SPACE;
+               if (out[i] >= A && out[i] <= Z)
+                       out[i] += SPACE;
        }
+
+       return out;
 }
 
-void rename_string(const char* src, char* dst)
+char* rename_string(char** src)
 {
-       size_t len = strlen(src) + 1;
-       char* out = malloc(len);
-       if (out == NULL)
-               return;
-
-       memcpy(out, src, len);
-
-       out = replace(&out, " ", "_");
+       char* out = replace(src, " ", "_");
        out = replace(&out, "ä", "ae");
        out = replace(&out, "Ä", "Ae");
        out = replace(&out, "ö", "oe");
@@ -106,21 +95,12 @@ void rename_string(const char* src, char* dst)
        out = replace(&out, "Ü", "Ue");
        out = replace(&out, "ß", "ss");
        
-       memcpy(dst, out, strlen(out) + 1);
-       free(out);
-       out = NULL;
+       return out;
 }
 
-void rename_revert(const char* src, char* dst)
+char* rename_revert(char** src)
 {
-       size_t len = strlen(src) + 1;
-       char* out = malloc(len);
-       if (out == NULL)
-               return;
-
-       memcpy(out, src, len);
-
-       out = replace(&out, "_", " ");
+       char* out = replace(src, "_", " ");
        out = replace(&out, "ae", "ä");
        out = replace(&out, "Ae", "Ä");
        out = replace(&out, "oe", "ö");
@@ -129,8 +109,6 @@ void rename_revert(const char* src, char* dst)
        out = replace(&out, "Ue", "Ü");
        out = replace(&out, "ss", "ß");
 
-       memcpy(dst, out, strlen(out) + 1);
-       free(out);
-       out = NULL;
+       return out;
 }
 

diff --git a/src/rename.h b/src/rename.h
index e741a0259ce5c1f305cb2c69bd9ccf0d2df0b2f1..835ffb3e222458099f42d89cd8f0b8461e7df070 100644 (file)
--- a/src/rename.h
+++ b/src/rename.h
@@ -8,14 +8,15 @@
 #define A (char) 0x41
 #define Z (char) 0x5a
 
-typedef void (*rename_ptr)(const char* src, char* dst);
-
-void escape(const char* src, char* dst);
-void rename_point(const char* src, char* dst);
-void rename_lower(const char* src, char* dst);
-void rename_string(const char* src, char* dst);
-void rename_revert(const char* src, char* dst);
+typedef char* (*rename_ptr)(char** src);
 
+char* strdup(const char* str);
 char* replace(char** src, const char* pattern, const char* replace_str);
 
+char* escape(char** src);
+char* rename_point(char** src);
+char* rename_lower(char** src);
+char* rename_string(char** src);
+char* rename_revert(char** src);
+
 #endif
\ No newline at end of file

diff --git a/tests/rename_tests.c b/tests/rename_tests.c
index 1b3b7b1395dd184b8ed6589c66213c60f2dc3c1e..3235130d79187a730d5307a3b02f8b3d27581459 100644 (file)
--- a/tests/rename_tests.c
+++ b/tests/rename_tests.c
@@ -7,236 +7,261 @@
 #include <string.h>
 #include "../src/rename.h"
 
-int setup_group(void** state)
+void str_dup()
 {
-       char* output = malloc(STR_MAX_LENGTH);
-       if (output == NULL)
-               return 1;
+       const char* str = "Der String";
 
-       *state = output;
-       return 0;
-}
+       char* out = strdup(str);
 
-int teardown_group(void** state)
-{
-       free(*state);
-       *state = NULL;
+       assert_string_equal(out, "Der String");
 
-       return 0;
-}
-
-int setup(void** state)
-{
-       memset(*state, 0, STR_MAX_LENGTH);
-       return 0;
+       free(out);
+       out = NULL;
 }
 
-void rename_spaces(void** state)
+void rename_spaces()
 {
-       char* output = (char*) *state;
-       const char* input = "Dies ist ein Test Satz";
+       char* input = strdup("Dies ist ein Test Satz");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Dies_ist_ein_Test_Satz");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_ae(void** state)
+void rename_ae()
 {
-       char* output = (char*) *state;
-       const char* input = "wäre";
+       char* input = strdup("wäre");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "waere");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_Ae(void** state)
+void rename_Ae()
 {
-       char* output = (char*) *state;
-       const char* input = "Ächtzen";
+       char* input = strdup("Ächtzen");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Aechtzen");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_oe(void** state)
+void rename_oe()
 {
-       char* output = (char*) *state;
-       const char* input = "König";
+       char* input = strdup("König");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Koenig");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_Oe(void** state)
+void rename_Oe()
 {
-       char* output = (char*) *state;
-       const char* input = "Ökosystem";
+       char* input = strdup("Ökosystem");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Oekosystem");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_ue(void** state)
+void rename_ue()
 {
-       char* output = (char*) *state;
-       const char* input = "brüllt";
+       char* input = strdup("brüllt");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "bruellt");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_Ue(void** state)
+void rename_Ue()
 {
-       char* output = (char*) *state;
-       const char* input = "Überlastung";
+       char* input = strdup("Überlastung");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Ueberlastung");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_scharfes_s(void** state)
+void rename_scharfes_s()
 {
-       char* output = (char*) *state;
-       const char* input = "Gruß";
+       char* input = strdup("Gruß");
 
-       rename_string(input, output);
+       char* output = rename_string(&input);
 
        assert_string_equal(output, "Gruss");
+
+       free(output);
+       output = NULL;
 }
 
-void none_replace_wide_char(void** state)
+void none_replace_wide_char()
 {
-       char* output = (char*) *state;
-       const char* none_replace = "ō";
+       char* none_replace = strdup("ō");
 
-       rename_string(none_replace, output);
+       char* output = rename_string(&none_replace);
 
-       assert_string_equal(output, none_replace);
+       assert_string_equal(output, "ō");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_lower_case(void** state)
+void rename_lower_case()
 {
-       char* output = (char*) *state;
-       const char* input = "Gruß Gott, hat der Biergarten offen?";
+       char* input = strdup("Gruß Gott, hat der Biergarten offen?");
 
-       rename_lower(input, output);
+       char* output = rename_lower(&input);
 
        assert_string_equal(output, "gruss_gott,_hat_der_biergarten_offen?");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_point_case(void** state)
+void rename_point_case()
 {
-       char* output = (char*) *state;
-       const char* input = "Dies ist die Geschichte von...........";
+       char* input = strdup("Dies ist die Geschichte von...........");
 
-       rename_point(input, output);
+       char* output = rename_point(&input);
 
        assert_string_equal(output, "Dies_ist_die_Geschichte_von");
+
+       free(output);
+       output = NULL;
 }
 
-void escape_test(void** state)
+void escape_test()
 {
-       char* output = (char*) *state;
-       const char* input = "Dies ist [die] (Geschichte) {von}";
+       char* input = strdup("Dies ist [die] (Geschichte) {von}");
 
-       escape(input, output);
+       char* output = escape(&input);
 
        assert_string_equal(output, "Dies\\ ist\\ \\[die\\]\\ \\(Geschichte\\)\\ \\{von\\}");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_spaces(void** state)
+void rename_revert_spaces()
 {
-       char* output = (char*) *state;
-       const char* input = "Dies_ist_ein_Test_Satz";
+       char* input = strdup("Dies_ist_ein_Test_Satz");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "Dies ist ein Test Satz");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_ae(void** state)
+void rename_revert_ae()
 {
-       char* output = (char*) *state;
-       const char* input = "waere";
+       char* input = strdup("waere");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "wäre");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_Ae(void** state)
+void rename_revert_Ae()
 {
-       char* output = (char*) *state;
-       const char* input = "Aechtzen";
+       char* input = strdup("Aechtzen");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "Ächtzen");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_oe(void** state)
+void rename_revert_oe()
 {
-       char* output = (char*) *state;
-       const char* input = "Koenig";
+       char* input = strdup("Koenig");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "König");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_Oe(void** state)
+void rename_revert_Oe()
 {
-       char* output = (char*) *state;
-       const char* input = "Oekosystem";
+       char* input = strdup("Oekosystem");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "Ökosystem");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_ue(void** state)
+void rename_revert_ue()
 {
-       char* output = (char*) *state;
-       const char* input = "bruellt";
+       char* input = strdup("bruellt");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "brüllt");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_Ue(void** state)
+void rename_revert_Ue()
 {
-       char* output = (char*) *state;
-       const char* input = "Ueberlastung";
+       char* input = strdup("Ueberlastung");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "Überlastung");
+
+       free(output);
+       output = NULL;
 }
 
-void rename_revert_ss(void** state)
+void rename_revert_ss()
 {
-       char* output = (char*) *state;
-       const char* input = "Gruss";
+       char* input = strdup("Gruss");
 
-       rename_revert(input, output);
+       char* output = rename_revert(&input);
 
        assert_string_equal(output, "Gruß");
+
+       free(output);
+       output = NULL;
 }
 
 void replace_string()
 {
-       char* input = malloc(sizeof(char) * 11);
-       if (input == NULL)
-               return;
-       memcpy(input, "Hello Max!", 11);
+       char* input = strdup("Hello Max!");
 
        char* output = replace(&input, "Max", "World");
 
@@ -249,28 +274,29 @@ void replace_string()
 int main()
 {
        const struct CMUnitTest tests[] = {
-               cmocka_unit_test_setup(rename_spaces, setup),
-               cmocka_unit_test_setup(rename_ae, setup),
-               cmocka_unit_test_setup(rename_Ae, setup),
-               cmocka_unit_test_setup(rename_oe, setup),
-               cmocka_unit_test_setup(rename_Oe, setup),
-               cmocka_unit_test_setup(rename_ue, setup),
-               cmocka_unit_test_setup(rename_Ue, setup),
-               cmocka_unit_test_setup(none_replace_wide_char, setup),
-               cmocka_unit_test_setup(rename_scharfes_s, setup),
-               cmocka_unit_test_setup(rename_lower_case, setup),
-               cmocka_unit_test_setup(rename_point_case, setup),
-               cmocka_unit_test_setup(escape_test, setup),
-               cmocka_unit_test_setup(rename_revert_spaces, setup),
-               cmocka_unit_test_setup(rename_revert_ae, setup),
-               cmocka_unit_test_setup(rename_revert_Ae, setup),
-               cmocka_unit_test_setup(rename_revert_oe, setup),
-               cmocka_unit_test_setup(rename_revert_Oe, setup),
-               cmocka_unit_test_setup(rename_revert_ue, setup),
-               cmocka_unit_test_setup(rename_revert_Ue, setup),
-               cmocka_unit_test_setup(rename_revert_ss, setup),
+               cmocka_unit_test(str_dup),
+               cmocka_unit_test(rename_spaces),
+               cmocka_unit_test(rename_ae),
+               cmocka_unit_test(rename_Ae),
+               cmocka_unit_test(rename_oe),
+               cmocka_unit_test(rename_Oe),
+               cmocka_unit_test(rename_ue),
+               cmocka_unit_test(rename_Ue),
+               cmocka_unit_test(rename_scharfes_s),
+               cmocka_unit_test(none_replace_wide_char),
+               cmocka_unit_test(rename_lower_case),
+               cmocka_unit_test(rename_point_case),
+               cmocka_unit_test(escape_test),
+               cmocka_unit_test(rename_revert_spaces),
+               cmocka_unit_test(rename_revert_ae),
+               cmocka_unit_test(rename_revert_Ae),
+               cmocka_unit_test(rename_revert_oe),
+               cmocka_unit_test(rename_revert_Oe),
+               cmocka_unit_test(rename_revert_ue),
+               cmocka_unit_test(rename_revert_Ue),
+               cmocka_unit_test(rename_revert_ss),
                cmocka_unit_test(replace_string)
        };
 
-       return cmocka_run_group_tests(tests, setup_group, teardown_group);
+       return cmocka_run_group_tests(tests, NULL, NULL);
 }
\ No newline at end of file