trackler 2.2.1.42 → 2.2.1.43

data/tracks/c/exercises/anagram/src/example.c

@@ -5,7 +5,7 @@
 
 #include "anagram.h"
 
-char *lowercase(char *p)
+char *lower_case(char *p)
 {
    int len = strlen(p) + 1;
    char *lower = (char *)malloc(len);
@@ -24,15 +24,15 @@ int compare(const void *a, const void *b)
    return *(const char *)a - *(const char *)b;
 }
 
-struct Vector anagrams_for(char *in, struct Vector vin)
+struct vector anagrams_for(char *in, struct vector vin)
 {
-   struct Vector vout = {
+   struct vector vout = {
       malloc(MAX_STR_LEN * sizeof(char *)),
       0
    };
    char (*vout_vecp)[MAX_STR_LEN] = vout.vec;
 
-   char *lower = lowercase(in);
+   char *lower = lower_case(in);
    char *sorted = malloc(strlen(in) + 1);
    memcpy(sorted, lower, strlen(in) + 1);
    qsort(sorted, strlen(sorted), 1, compare);
@@ -40,7 +40,7 @@ struct Vector anagrams_for(char *in, struct Vector vin)
    char (*vecp)[MAX_STR_LEN] = vin.vec;
    int x;
    for (x = 0; x < vin.size; x++) {
-      char *input_lower = lowercase((char *)vecp);
+      char *input_lower = lower_case((char *)vecp);
       if (strcmp(input_lower, lower) != 0) {
          char *input_sorted = input_lower;
          qsort(input_sorted, strlen(input_sorted), 1, compare);

data/tracks/c/exercises/anagram/test/test_anagram.c

@@ -5,7 +5,7 @@
 #include "../src/anagram.h"
 
 // Empty vector for when expected output is nothing
-static struct Vector empty = {
+static struct vector empty = {
    NULL,
    0
 };
@@ -16,7 +16,7 @@ static int stringcmp(const void *a, const void *b)
 }
 
 // Asserts that the two input vectors are equal
-static void assert_equal_vector(struct Vector vout, struct Vector expected)
+static void assert_equal_vector(struct vector vout, struct vector expected)
 {
    // Sort actual and expected outputs for consistency
    qsort(expected.vec, expected.size, sizeof(char) * MAX_STR_LEN, stringcmp);
@@ -39,18 +39,19 @@ void test_no_matches(void)
       "pants"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("diaper", vin);
+   struct vector vout = anagrams_for("diaper", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }
 
 void test_detect_simple_anagram(void)
 {
+   TEST_IGNORE();               // delete this line to run test
    char inputs[][MAX_STR_LEN] = {
       "tan",
       "stand",
@@ -61,56 +62,59 @@ void test_detect_simple_anagram(void)
       "tan"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector expected = {
+   struct vector expected = {
       outputs,
       sizeof(outputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("ant", vin);
+   struct vector vout = anagrams_for("ant", vin);
    assert_equal_vector(vout, expected);
    free(vout.vec);
 }
 
 void test_does_not_confuse_different_duplicates(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "eagle"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("galea", vin);
+   struct vector vout = anagrams_for("galea", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }
 
 void test_eliminate_anagram_subsets(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "dog",
       "goody"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("good", vin);
+   struct vector vout = anagrams_for("good", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }
 
 void test_detect_anagram(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "enlists",
       "google",
@@ -122,23 +126,24 @@ void test_detect_anagram(void)
       "inlets"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector expected = {
+   struct vector expected = {
       outputs,
       sizeof(outputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("listen", vin);
+   struct vector vout = anagrams_for("listen", vin);
    assert_equal_vector(vout, expected);
    free(vout.vec);
 }
 
 void test_multiple_anagrams(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "gallery",
       "ballerina",
@@ -154,23 +159,24 @@ void test_multiple_anagrams(void)
       "largely"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector expected = {
+   struct vector expected = {
       outputs,
       sizeof(outputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("allergy", vin);
+   struct vector vout = anagrams_for("allergy", vin);
    assert_equal_vector(vout, expected);
    free(vout.vec);
 }
 
 void test_case_insensitive_anagrams(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "cashregister",
       "Carthorse",
@@ -181,23 +187,24 @@ void test_case_insensitive_anagrams(void)
       "Carthorse"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector expected = {
+   struct vector expected = {
       outputs,
       sizeof(outputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("Orchestra", vin);
+   struct vector vout = anagrams_for("Orchestra", vin);
    assert_equal_vector(vout, expected);
    free(vout.vec);
 }
 
 void test_unicode_anagrams(void)
 {
+   TEST_IGNORE();
    // These words don't make sense, they're just greek letters cobbled together.
    char inputs[][MAX_STR_LEN] = {
       "ΒΓΑ",
@@ -209,67 +216,70 @@ void test_unicode_anagrams(void)
       "ΒΓΑ"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector expected = {
+   struct vector expected = {
       outputs,
       sizeof(outputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("ΑΒΓ", vin);
+   struct vector vout = anagrams_for("ΑΒΓ", vin);
    assert_equal_vector(vout, expected);
    free(vout.vec);
 }
 
 void test_misleading_unicode_anagrams(void)
 {
+   TEST_IGNORE();
    // Despite what a human might think these words different letters, the input uses Greek A and B
    // while the list of potential anagrams uses Latin A and B.
    char inputs[][MAX_STR_LEN] = {
       "ABΓ"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("ΑΒΓ", vin);
+   struct vector vout = anagrams_for("ΑΒΓ", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }
 
 void test_does_not_detect_a_word_as_its_own_anagram(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "banana"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("banana", vin);
+   struct vector vout = anagrams_for("banana", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }
 
 void test_does_not_detect_a_differently_cased_word_as_its_own_anagram(void)
 {
+   TEST_IGNORE();
    char inputs[][MAX_STR_LEN] = {
       "bAnana"
    };
 
-   struct Vector vin = {
+   struct vector vin = {
       inputs,
       sizeof(inputs) / MAX_STR_LEN
    };
 
-   struct Vector vout = anagrams_for("banana", vin);
+   struct vector vout = anagrams_for("banana", vin);
    assert_equal_vector(vout, empty);
    free(vout.vec);
 }

data/tracks/c/exercises/atbash-cipher/test/test_atbash_cipher.c

@@ -28,63 +28,75 @@ void test_encode_yes(void)
 
 void test_encode_no(void)
 {
+   TEST_IGNORE();
    test_encode("no", "ml");
 }
 
 void test_encode_OMG(void)
 {
+   TEST_IGNORE();
    test_encode("OMG", "lnt");
 }
 
 void test_encode_spaces(void)
 {
+   TEST_IGNORE();
    test_encode("O M G", "lnt");
 }
 
 void test_encode_mindblowingly(void)
 {
+   TEST_IGNORE();
    test_encode("mindblowingly", "nrmwy oldrm tob");
 }
 
 void test_encode_numbers(void)
 {
+   TEST_IGNORE();
    test_encode("Testing,1 2 3, testing.", "gvhgr mt123 gvhgr mt");
 }
 
 void test_encode_deep_thought(void)
 {
+   TEST_IGNORE();
    test_encode("Truth is fiction.", "gifgs rhurx grlm");
 }
 
 void test_encode_all_the_letters(void)
 {
+   TEST_IGNORE();
    test_encode("The quick brown fox jumps over the lazy dog.",
                "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt");
 }
 
 void test_encode_ignores_non_ascii(void)
 {
+   TEST_IGNORE();
    test_encode("non ascii éignored", "mlmzh xrrrt mlivw");
 }
 
 void test_decode_exercism(void)
 {
+   TEST_IGNORE();
    test_decode("vcvix rhn", "exercism");
 }
 
 void test_decode_a_sentence(void)
 {
+   TEST_IGNORE();
    test_decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v",
                "anobstacleisoftenasteppingstone");
 }
 
 void test_decode_numbers(void)
 {
+   TEST_IGNORE();
    test_decode("gvhgr mt123 gvhgr mt", "testing123testing");
 }
 
 void test_decode_all_the_letters(void)
 {
+   TEST_IGNORE();
    test_decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
                "thequickbrownfoxjumpsoverthelazydog");
 }

data/tracks/c/exercises/beer-song/test/test_beer_song.c

@@ -16,6 +16,7 @@ void test_handles_arbitrary_verse(void)
 
 void test_handles_2_bottles(void)
 {
+   TEST_IGNORE();               // delete this line to run test
    char response[BUFFER_SIZE];
    const char expected[BUFFER_SIZE] =
        "2 bottles of beer on the wall, 2 bottles of beer.\n"
@@ -27,6 +28,7 @@ void test_handles_2_bottles(void)
 
 void test_handles_1_bottle(void)
 {
+   TEST_IGNORE();
    char response[BUFFER_SIZE];
    const char expected[BUFFER_SIZE] =
        "1 bottle of beer on the wall, 1 bottle of beer.\n"
@@ -38,6 +40,7 @@ void test_handles_1_bottle(void)
 
 void test_handles_0_bottles(void)
 {
+   TEST_IGNORE();
    char response[BUFFER_SIZE];
    const char expected[BUFFER_SIZE] =
        "No more bottles of beer on the wall, no more bottles of beer.\n"
@@ -49,6 +52,7 @@ void test_handles_0_bottles(void)
 
 void test_sings_several_verses(void)
 {
+   TEST_IGNORE();
    char response[BUFFER_SIZE];
    const char expected[BUFFER_SIZE] =
        "8 bottles of beer on the wall, 8 bottles of beer.\n"
@@ -66,6 +70,7 @@ void test_sings_several_verses(void)
 
 void test_sings_the_last_4_verses(void)
 {
+   TEST_IGNORE();
    char response[BUFFER_SIZE];
    const char expected[BUFFER_SIZE] =
        "3 bottles of beer on the wall, 3 bottles of beer.\n"

data/tracks/c/exercises/binary-search/test/test_binary_search.c

@@ -10,6 +10,7 @@ void test_single_element(void)
 
 void test_value_in_middle(void)
 {
+   TEST_IGNORE();               // delete this line to run test
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(&arr[3], binary_search(6, arr, length));
@@ -17,6 +18,7 @@ void test_value_in_middle(void)
 
 void test_value_at_beginning(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(&arr[0], binary_search(1, arr, length));
@@ -24,6 +26,7 @@ void test_value_at_beginning(void)
 
 void test_value_at_end(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(&arr[6], binary_search(11, arr, length));
@@ -31,6 +34,7 @@ void test_value_at_end(void)
 
 void test_find_value_with_odd_length(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(&arr[9], binary_search(144, arr, length));
@@ -38,6 +42,7 @@ void test_find_value_with_odd_length(void)
 
 void test_find_value_with_even_length(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(&arr[5], binary_search(21, arr, length));
@@ -45,6 +50,7 @@ void test_find_value_with_even_length(void)
 
 void test_identify_missing_value(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(NULL, binary_search(7, arr, length));
@@ -52,6 +58,7 @@ void test_identify_missing_value(void)
 
 void test_value_smaller_than_everything(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(NULL, binary_search(0, arr, length));
@@ -59,6 +66,7 @@ void test_value_smaller_than_everything(void)
 
 void test_value_larger_than_everything(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1, 3, 4, 6, 8, 9, 11 };
    size_t length = sizeof(arr) / sizeof(arr[0]);
    TEST_ASSERT_EQUAL_PTR(NULL, binary_search(13, arr, length));
@@ -66,6 +74,7 @@ void test_value_larger_than_everything(void)
 
 void test_empty_array(void)
 {
+   TEST_IGNORE();
    int *arr = NULL;
    size_t length = 0;
    TEST_ASSERT_EQUAL_PTR(NULL, binary_search(1, arr, length));
@@ -73,6 +82,7 @@ void test_empty_array(void)
 
 void test_zero_length_array(void)
 {
+   TEST_IGNORE();
    int arr[] = { 1 };
    size_t length = 0;
    TEST_ASSERT_EQUAL_PTR(NULL, binary_search(1, arr, length));