⚠ Do not use a plain integer constant with malloc(…).

Specify the number of bytes to allocate as an expression using sizeof(…).

⚠ Do not use a type with sizeof(…)

The C language also allows another form of the sizeof(…) operator: sizeof(TYPE) (← BAD!). Do not use this form. Some people might write the above malloc call as malloc(sizeof(char) * 4) (← BAD!). That form is outdated because it is bug-prone. Don't use it. If you later change the type of the type on the left, you may end up allocating the wrong amount of memory. That can cause serious bugs with security consequences. To avoid those problems, whenever you call malloc(…), pass an expression using sizeof(…) with an expression, not a type.

⚠ Don't forget the asterisk ("*") in the sizeof(…) expression.

If you forget the asterisk in your sizeof(…) expression, you may allocate the wrong amount of memory, leading to bufffer overflow errors which can be challenging to find. Remember your asterisk!

⚠ Do not typecast the return value of malloc(…) in C code.

Some people who learned older C coding practices were taught to always typecast the result of malloc(…). For example, they would do the above call like this: char* abc_string = (char*)malloc(sizeof(*abc_string) * 4). That is not needed in C. malloc(…) returns a void* (generic memory address with no expectations about what type will be stored at that address). You are assigning that to a char*. That requires no typecast. The typecast only creates opportunities for bugs. Typecasts are not allowed in this class, except where you know a clear reason why the typecast is necessary and why it is safe.

Copy your log_macros.h, miniunit.h, and Makefile from previous assignments.

Update your Makefile

You should only need to modify three lines.

# VARIABLES
ASG_NICKNAME = HW09
BASE_NAME = join_strings
SUBMIT_FILES = $(SRC_C) $(TEST_C) miniunit.h log_macros.h Makefile
…

Your SUBMIT_FILES variable might vary in how it uses the other variables. Just make sure that when all variables have been expanded, SUBMIT_FILES includes all of the files that must be submitted with this assignment.

Create a test file (test_join_strings.c) with one minimal test for copy_string(…)

This test will test if copy_string(…) can correctly copy an empty string (i.e., "").

⚠ Do not skip this step. A common mistake on homework assignments like this is to mess up the '\0'. If you have a very simple test that takes care of that—and get it working and tested before doing the rest of this assignment—you will make sure you can solve this issue in isolation before adding any further complexity.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include "join_strings.h"
#include "miniunit.h"

static int _test_copy_string_empty() {
    mu_start();
    //────────────────────
    char const* s_orig = "";
    char* s_copy = copy_string(s_orig);
    mu_check_strings_equal(s_copy, s_orig);
    free(s_copy);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    mu_run(_test_copy_string_empty);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

In the above example, s_orig is declared as char const* s_orig. The const ensures that you cannot accidentally write to *s_orig (i.e., you cannot write to the individual characters in s_orig).

Implement just enough of copy_string(…) in join_strings.c to pass that test.

Hint: You will call malloc(…) and implement enough for a buffer to contain just one character (i.e., the '\0'.) Then, write the '\0' to the buffer.

Get this test passing before you add any more tests.

Submit.

Add a second test for copy_string(…).

This will test if copy_string(…) can copy a non-empty string (i.e., "abc").

// …

static int _test_copy_string_abc() {
    mu_start();
    //────────────────────
    char const* s_orig = "abc";
    char* s_copy = copy_string(s_orig);
    mu_check_strings_equal(s_copy, s_orig);
    free(s_copy);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_copy_string_abc);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Implement just enough of copy_string(…) in join_strings.c to pass that test.

Hint: You can use strlen(…) to get the number of characters in string (not including the '\0').

Hint: When you call malloc(…), be sure to allocate enough memory for all of the characters in string, and the '\0'.

Hint: You can use strcpy(destination string, source string) to copy a string. For example, if s_copy is the new buffer on the heap that you will copy into, then strcpy(s_copy, string) will copy all of the characters in string and the '\0' to the buffer at s_copy.

strlen(…) and strcpy(…) are declared in the standard header file string.h. To you use them, you must include that header file in the same way you would include stdio.h or stdlib.h.

Submit.

Add a minimal test for wrap_string(…).

This will test if wrap_string(…) can correctly copy an empty string, including the specified left and right delimiter characters. (For examples, see the Requirements table below.)

// …

static int _test_wrap_string_empty() {
    mu_start();
    //────────────────────
    char* s_copy = wrap_string("", '[', ']');
    mu_check_strings_equal(s_copy, "[]");
    free(s_copy);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_wrap_string_empty);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Implement just enough of wrap_string(…) in join_strings.c to pass that test.

Hint: For this stage, you should not need strlen(…), strcpy(…), memcpy(…), or any loops.

Submit.

Add a more substantial test for wrap_string(…).

This will test if wrap_string(…) can correctly copy a non-empty string , including the specified left and right delimiter characters.

// …

static int _test_wrap_string_abc() {
    mu_start();
    //────────────────────
    char* s_copy = wrap_string("abc", '[', ']');
    mu_check_strings_equal(s_copy, "[abc]");
    free(s_copy);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_wrap_string_abc);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Implement just enough of wrap_string(…) in join_strings.c to pass that test.

Hint: You can use memcpy(destination, source, num_bytes) to copy a specified number of bytes (num_bytes) from one buffer (source) to another (destination). Unlike strcpy(…), memcpy(…) does not copy the '\0'. It copies a specified number of bytes. memcpy(…) is equivalent to the following code:

void* memcpy(void* destination, void const* source, size_t num_bytes) {
    for(size_t i = 0; i < num_bytes; i++) {
        destination[i] = source[i];  // copy one byte from source to destination
    }
    return destination; // return destination (for convenience)
}

Reminder: void* is a type that means address of anything, and you can assign an anything* to a void*. Since wrap_string(…) will be dealing with a buffer of char, you can imagine the signature of memcpy(…) was char* memcpy(char* destination, char const* source).

Reminder: size_t is an unsigned integer type that is guaranteed to be sufficient to store the number of bytes in any array on the current system. While it may be tempting to use int everywhere, since it is familiar, there could be arrays (including strings) with more than INT_MAX bytes.

Add a minimal test for join_strings(…).

This will test if join_strings(…) can correctly copy an array containing a single string. Since the delimiter only comes between successive strings in the array, the delimiter will be ignored for this test case. (For more examples, see the Requirements table below.)

// …

static int _test_join_strings_one() {
    mu_start();
    //────────────────────
    char const* const strings[] = { "abc" };
    char* combined_str = join_strings(strings, 1, "-");
    mu_check_strings_equal(combined_str, "abc");
    free(combined_str);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_join_strings_one);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Note that strings is declared as char const* const strings[]. That means strings is an array of char*. Thus, strings[0] is the address of the 'a' in "abc". The const makes it work with join_strings(…), which has some protections to prevent you from accidentally modifying the array of strings that is passed in, or any character within any of those strings.

join_strings(…) is declared in join_strings.h as follows:

char* join_strings(char const* const* strings, size_t num_strings, char const* separator)

The first const ensures that you cannot accidentally modify **strings (first character in the first string)—or any other character in any of the strings. In other words, if you try to do strings[▒][▒] = '▒';, gcc will give you an error message to prevent you from making that mistake.

The second const ensures that you cannot accidentally modify *strings (the first string)—or any string in the array. In other words, if you had some other string elsewhere in memory (e.g., other_string), you cannot do strings[▒] = other_string;. Gcc would give you an error message to save you.

⚠ Do not use typecasts anywhere in HW09.

Implement just enough of join_strings(…) in join_strings.c to pass that test.

Hint: For this stage, join_strings(…) should do nothing more than copy_string(…).

⚠ Do not skip this step and do not try to implement the whole thing at this stage. Just get it working for a single string. If it contains any more code than your copy_string(…), you are not following directions and should expect problems. Get join_strings(…) working for just this simple case first. There are some complexities with the type of the argument that you will want to iron out before you add anything further.

Submit.

Add a more test for join_strings(…) with multiple strings but an empty delimiter.

// …

static int _test_join_strings_three_empty_delimiter() {
    mu_start();
    //────────────────────
    char const* const strings[] = { "abc", "def", "ghi" };
    char* combined_str = join_strings(strings, 3, "");
    mu_check_strings_equal(combined_str, "abcdefghi");
    free(combined_str);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_join_strings_three_empty_delimiter);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Implement just enough of join_strings(…) in join_strings.c to pass that test.

Reminder: Do not use typecasts anywhere in HW09.

Submit.

Add another test for join_strings(…) with multiple strings and a non-empty delimiter.

// …

static int _test_join_strings_three_nonempty_delimiter() {
    mu_start();
    //────────────────────
    char const* const strings[] = { "abc", "def", "ghi" };
    char* combined_str = join_strings(strings, 3, "-");
    mu_check_strings_equal(combined_str, "abc-def-ghi");
    free(combined_str);
    //────────────────────
    mu_end();
}

int main(int argc, char* argv[]) {
    // …
    mu_run(_test_join_strings_three_nonempty_delimiter);
    return EXIT_SUCCESS;
}
// Okay to copy/adapt code from this example.

Implement just enough of join_strings(…) in join_strings.c to pass that test.

Submit.

Continue until finished

You are almost done. You still need to test join_strings(…) for an empty array (i.e., join_strings(NULL, 0, "-")). Also, make sure your tests are adequate.

Requirements

Submit

To submit HW09 from within your hw09 directory, type

make submit

That should result in the following command: 264submit HW09 join_strings.c test_join_strings.c miniunit.h log_macros.h Makefile

Pretester

Pre-tester ●

The pre-tester for HW09 has been released and is ready to use.