trackler 2.2.1.59 → 2.2.1.60

data/tracks/c/exercises/word-count/src/example.c

@@ -20,7 +20,7 @@ static int word_match(char *testWord, int current_word_count,
    return match_index;
 }
 
-int word_count(char *input_text, word_count_word_t words[MAX_WORDS])
+int word_count(const char *input_text, word_count_word_t * words)
 {
    int index;
    int unique_words = 0;
@@ -36,7 +36,7 @@ int word_count(char *input_text, word_count_word_t words[MAX_WORDS])
    lower_case_input_text[index] = '\0';
 
    // start with known results...
-   memset(words, 0, sizeof(word_count_word_t));
+   memset(words, 0, sizeof(word_count_word_t) * MAX_WORDS);
 
    test_word = strtok(lower_case_input_text, delimiters);
    while (test_word != NULL) {
@@ -50,8 +50,17 @@ int word_count(char *input_text, word_count_word_t words[MAX_WORDS])
 
       // add if not yet counted else increment count.
       if (-1 == index) {
+         // reject anything that would overrun buffers
+         if (MAX_WORD_LENGTH < strlen(test_word)) {
+            unique_words = EXCESSIVE_LENGTH_WORD;
+            break;
+         }
+         if (MAX_WORDS == unique_words) {
+            unique_words = EXCESSIVE_NUMBER_OF_WORDS;
+            break;
+         }
          words[unique_words].count = 1;
-         strcpy(words[unique_words].text, test_word);
+         strncpy(words[unique_words].text, test_word, MAX_WORD_LENGTH);
          unique_words++;
       } else {
          words[index].count++;

data/tracks/c/exercises/word-count/src/word_count.h

@@ -1,8 +1,8 @@
 #ifndef WORD_COUNT_H
 #define WORD_COUNT_H
 
-#define MAX_WORDS 20            // at most MAX_WORDS will be found in the test input string
-#define MAX_WORD_LENGTH 50      // no individual word will exceed this length
+#define MAX_WORDS 20            // at most MAX_WORDS can be found in the test input string
+#define MAX_WORD_LENGTH 50      // no individual word can exceed this length
 
 // results structure
 typedef struct word_count_word {
@@ -10,13 +10,18 @@ typedef struct word_count_word {
    int count;
 } word_count_word_t;
 
+#define EXCESSIVE_LENGTH_WORD     -1
+#define EXCESSIVE_NUMBER_OF_WORDS -2
+
 // word_count - routine to classify the unique words and their frequency in a test input string
 // inputs:
-//    input_text =  string no longer than will take (MAX_WORDS * MAX_WORD_LENGTH)
-//    words = allocated structure to record the words fourn and their frequency
+//    input_text =  a null-terminated string containing that is analyzed
 //
 // outputs:
+//    words = allocated structure to record the words found and their frequency
 //    uniqueWords - number of words in the words structure
-int word_count(char *input_text, word_count_word_t words[MAX_WORDS]);
+//           returns a negative number if an error.
+//           words will contain the results up to that point.
+int word_count(const char *input_text, word_count_word_t * words);
 
 #endif

data/tracks/c/exercises/word-count/test/test_word_count.c

@@ -5,7 +5,7 @@
 #include "../src/word_count.h"
 
 word_count_word_t actual_solution[MAX_WORDS];
-
+word_count_word_t expected_solution[MAX_WORDS];
 void setUp(void)
 {
 }
@@ -14,28 +14,24 @@ void tearDown(void)
 {
 }
 
-static void test_solution(word_count_word_t * expected_solution,
-                          int expected_word_count,
-                          word_count_word_t * actual_solution,
-                          int actual_word_count)
+static void check_solution(word_count_word_t * expected_solution,
+                           int expected_word_count,
+                           word_count_word_t * actual_solution,
+                           int actual_word_count)
 {
    // All words counted?
    TEST_ASSERT_EQUAL(expected_word_count, actual_word_count);
 
    // now test the word count for the words...
-   for (int index = 0; index < actual_word_count; index++) {
+   for (int index = 0; index < MAX_WORDS; index++) {
       TEST_ASSERT_EQUAL(expected_solution[index].count,
                         actual_solution[index].count);
-      TEST_ASSERT_EQUAL_STRING(expected_solution[index].text,
-                               actual_solution[index].text);
+      TEST_ASSERT_EQUAL_UINT8_ARRAY(expected_solution[index].text,
+                                    actual_solution[index].text,
+                                    MAX_WORD_LENGTH);
    }
 }
 
-static void reset_actual_solution(void)
-{
-   memset(actual_solution, 0, sizeof(actual_solution));
-}
-
 // Tests Start here
 void test_word_count_one_word(void)
 {
@@ -43,7 +39,6 @@ void test_word_count_one_word(void)
    int actual_word_count;
    char *input_text = "word";
    const int expected_word_count = 1;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -52,12 +47,10 @@ void test_word_count_one_word(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "word", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
-
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_one_of_each_word(void)
@@ -67,7 +60,6 @@ void test_word_count_one_of_each_word(void)
    int actual_word_count;
    char *input_text = "one of each";
    const int expected_word_count = 3;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -82,11 +74,10 @@ void test_word_count_one_of_each_word(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "each", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_multiple_occurrences_of_a_word(void)
@@ -96,7 +87,6 @@ void test_word_count_multiple_occurrences_of_a_word(void)
    int actual_word_count;
    char *input_text = "one fish two fish red fish blue fish";
    const int expected_word_count = 5;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -116,11 +106,10 @@ void test_word_count_multiple_occurrences_of_a_word(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "blue", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_handles_cramped_lists(void)
@@ -130,7 +119,6 @@ void test_word_count_handles_cramped_lists(void)
    int actual_word_count;
    char *input_text = "one,two,three";
    const int expected_word_count = 3;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -144,11 +132,10 @@ void test_word_count_handles_cramped_lists(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_handles_expanded_lists(void)
@@ -158,7 +145,6 @@ void test_word_count_handles_expanded_lists(void)
    int actual_word_count;
    char *input_text = "one,\ntwo,\nthree";
    const int expected_word_count = 3;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -172,11 +158,10 @@ void test_word_count_handles_expanded_lists(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_ignore_punctuation(void)
@@ -186,7 +171,6 @@ void test_word_count_ignore_punctuation(void)
    int actual_word_count;
    char *input_text = "car: carpet as java: javascript!!&@$%^&";
    const int expected_word_count = 5;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -206,11 +190,10 @@ void test_word_count_ignore_punctuation(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "javascript", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_include_numbers(void)
@@ -220,7 +203,6 @@ void test_word_count_include_numbers(void)
    int actual_word_count;
    char *input_text = "testing, 1, 2 testing";
    const int expected_word_count = 3;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -234,11 +216,10 @@ void test_word_count_include_numbers(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "2", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_normalize_case(void)
@@ -248,7 +229,6 @@ void test_word_count_normalize_case(void)
    int actual_word_count;
    char *input_text = "go Go GO Stop stop";
    const int expected_word_count = 2;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -259,11 +239,10 @@ void test_word_count_normalize_case(void)
    expected_solution[index].count = 2;
    strncpy(expected_solution[index++].text, "stop", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_with_apostrophes(void)
@@ -273,7 +252,6 @@ void test_word_count_with_apostrophes(void)
    int actual_word_count;
    char *input_text = "First: don't laugh. Then: don't cry.";
    const int expected_word_count = 5;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -293,11 +271,10 @@ void test_word_count_with_apostrophes(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "cry", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_with_quotation(void)
@@ -307,7 +284,6 @@ void test_word_count_with_quotation(void)
    int actual_word_count;
    char *input_text = "Joe can't tell between 'large' and large.";
    const int expected_word_count = 6;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -330,11 +306,10 @@ void test_word_count_with_quotation(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "and", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_from_example(void)
@@ -344,7 +319,6 @@ void test_word_count_from_example(void)
    int actual_word_count;
    char *input_text = "olly olly in come free";
    const int expected_word_count = 4;
-   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
@@ -361,11 +335,223 @@ void test_word_count_from_example(void)
    expected_solution[index].count = 1;
    strncpy(expected_solution[index++].text, "free", MAX_WORD_LENGTH);
 
-   reset_actual_solution();
    actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(expected_solution,
-                 expected_word_count, actual_solution, actual_word_count);
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
+}
+
+void test_max_length_word(void)
+{
+   TEST_IGNORE();
+   int actual_word_count;
+   int index = 0;
+   char *input_text =
+       "Look thisisaninsanelylongwordtypedwithoutusinganyspaces and look again, thisisaninsanelylongwordtypedwithoutusinganyspaces";
+
+   const int expected_word_count = 4;
+
+   // build the expected solution
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
+
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "look", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text,
+           "thisisaninsanelylongwordtypedwithoutusinganyspaces",
+           MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "and", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "again", MAX_WORD_LENGTH);
+
+   actual_word_count = word_count(input_text, actual_solution);
+
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
+}
+
+void test_excessive_length_word(void)
+{
+   TEST_IGNORE();
+   int actual_word_count;
+   int index = 0;
+   char *input_text =
+       "Look thisisanexcessivelylongwordthatsomeonetypedwithoutusingthespacebar enough";
+
+   const int expected_word_count = EXCESSIVE_LENGTH_WORD;
+   word_count_word_t expected_solution[MAX_WORDS];
+
+   // build the expected solution
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "look", MAX_WORD_LENGTH);
+
+   actual_word_count = word_count(input_text, actual_solution);
+
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
+}
+
+void test_max_number_words(void)
+{
+   TEST_IGNORE();
+   int actual_word_count;
+   int index = 0;
+   char *input_text =
+       "Once upon a time, a long while in the past, there lived a strange little man who could spin straw into gold";
+
+   const int expected_word_count = 20;
+
+   // build the expected solution
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "once", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "upon", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 3;
+   strncpy(expected_solution[index++].text, "a", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "time", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "long", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "while", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "the", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "past", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "there", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "lived", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "strange", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "little", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "man", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "who", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "could", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "spin", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "straw", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "into", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "gold", MAX_WORD_LENGTH);
+
+   actual_word_count = word_count(input_text, actual_solution);
+
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
+}
+
+void test_excessive_number_words(void)
+{
+   TEST_IGNORE();
+   int actual_word_count;
+   int index = 0;
+   char *input_text =
+       "Once upon a time, a long while in the past, there lived a strange little man who could spin straw into gold. His name was...";
+
+   const int expected_word_count = EXCESSIVE_NUMBER_OF_WORDS;
+
+   // build the expected solution
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "once", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "upon", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 3;
+   strncpy(expected_solution[index++].text, "a", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "time", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "long", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "while", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "the", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "past", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "there", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "lived", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "strange", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "little", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "man", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "who", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "could", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "spin", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "straw", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "into", MAX_WORD_LENGTH);
+
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "gold", MAX_WORD_LENGTH);
+
+   actual_word_count = word_count(input_text, actual_solution);
+
+   check_solution(expected_solution,
+                  expected_word_count, actual_solution, actual_word_count);
 }
 
 int main(void)
@@ -383,6 +569,10 @@ int main(void)
    RUN_TEST(test_word_count_with_apostrophes);
    RUN_TEST(test_word_count_with_quotation);
    RUN_TEST(test_word_count_from_example);
+   RUN_TEST(test_max_length_word);
+   RUN_TEST(test_excessive_length_word);
+   RUN_TEST(test_max_number_words);
+   RUN_TEST(test_excessive_number_words);
 
    UnityEnd();