trackler 2.2.1.45 → 2.2.1.46

data/tracks/c/exercises/triangle/src/triangle.h

@@ -5,6 +5,6 @@ typedef struct {
    double a;
    double b;
    double c;
-} Triangle_t;
+} triangle_t;
 
 #endif

data/tracks/c/exercises/triangle/test/test_triangle.c

@@ -3,118 +3,119 @@
 
 void test_equilateral_is_true_if_all_sides_are_equal(void)
 {
-   Triangle_t sides = { 2, 2, 2 };
+   triangle_t sides = { 2, 2, 2 };
    TEST_ASSERT_TRUE(is_equilateral(&sides));
 }
 
 void test_equilateral_is_false_if_any_side_is_unequal(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   Triangle_t sides = { 2, 3, 2 };
+   triangle_t sides = { 2, 3, 2 };
    TEST_ASSERT_FALSE(is_equilateral(&sides));
 }
 
 void test_equilateral_is_false_if_all_sides_zero(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 0, 0, 0 };
+   triangle_t sides = { 0, 0, 0 };
    TEST_ASSERT_FALSE(is_equilateral(&sides));
 }
 
 void test_equilateral_sides_may_be_floats(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 0.5, 0.5, 0.5 };
+   triangle_t sides = { 0.5, 0.5, 0.5 };
    TEST_ASSERT_TRUE(is_equilateral(&sides));
 }
 
 void test_isosceles_is_true_if_last_two_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 3, 4, 4 };
+   triangle_t sides = { 3, 4, 4 };
    TEST_ASSERT_TRUE(is_isosceles(&sides));
 }
 
 void test_isosceles_is_true_if_first_two_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 4, 4, 3 };
+   triangle_t sides = { 4, 4, 3 };
    TEST_ASSERT_TRUE(is_isosceles(&sides));
 }
 
 void test_isosceles_is_true_if_first_and_last_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 4, 3, 4 };
+   triangle_t sides = { 4, 3, 4 };
    TEST_ASSERT_TRUE(is_isosceles(&sides));
 }
 
 void test_equilateral_triangles_are_also_isosceles(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 4, 4, 4 };
+   triangle_t sides = { 4, 4, 4 };
    TEST_ASSERT_TRUE(is_isosceles(&sides));
 }
 
 void test_isosceles_is_false_if_no_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 2, 3, 4 };
+   triangle_t sides = { 2, 3, 4 };
    TEST_ASSERT_FALSE(is_isosceles(&sides));
 }
 
 void test_isosceles_is_false_if_two_sides_equal_and_violate_inequality(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 1, 1, 3 };
+   triangle_t sides = { 1, 1, 3 };
    TEST_ASSERT_FALSE(is_isosceles(&sides));
 }
 
 void test_isosceles_sides_may_be_floats(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 0.5, 0.4, 0.5 };
+   triangle_t sides = { 0.5, 0.4, 0.5 };
    TEST_ASSERT_TRUE(is_isosceles(&sides));
 }
 
 void test_scalene_is_true_if_no_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 5, 4, 6 };
+   triangle_t sides = { 5, 4, 6 };
    TEST_ASSERT_TRUE(is_scalene(&sides));
 }
 
 void test_scalene_is_false_if_all_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 4, 4, 4 };
+   triangle_t sides = { 4, 4, 4 };
    TEST_ASSERT_FALSE(is_scalene(&sides));
 }
 
 void test_scalene_is_false_if_two_sides_are_equal(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 4, 4, 3 };
+   triangle_t sides = { 4, 4, 3 };
    TEST_ASSERT_FALSE(is_scalene(&sides));
 }
 
 void test_scalene_is_false_if_no_sides_equal_and_violate_inequality(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 7, 3, 2 };
+   triangle_t sides = { 7, 3, 2 };
    TEST_ASSERT_FALSE(is_scalene(&sides));
 }
 
 void test_scalene_sides_may_be_floats(void)
 {
    TEST_IGNORE();
-   Triangle_t sides = { 0.5, 0.4, 0.6 };
+   triangle_t sides = { 0.5, 0.4, 0.6 };
    TEST_ASSERT_TRUE(is_scalene(&sides));
 }
 
 int main(void)
 {
    UnityBegin("test/test_triangle.c");
+
    RUN_TEST(test_equilateral_is_true_if_all_sides_are_equal);
    RUN_TEST(test_equilateral_is_false_if_any_side_is_unequal);
    RUN_TEST(test_equilateral_is_false_if_all_sides_zero);
@@ -131,6 +132,7 @@ int main(void)
    RUN_TEST(test_scalene_is_false_if_two_sides_are_equal);
    RUN_TEST(test_scalene_is_false_if_no_sides_equal_and_violate_inequality);
    RUN_TEST(test_scalene_sides_may_be_floats);
+
    UnityEnd();
    return 0;
 }

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

@@ -7,59 +7,59 @@
 // if word counted already it returns index,
 // else returns -1
 static int word_match(char *testWord, int current_word_count,
-                      WordCount_Word_t words[MAX_WORDS])
+                      word_count_word_t words[MAX_WORDS])
 {
-   int matchIndex = -1;
+   int match_index = -1;
 
    for (int index = 0; index < current_word_count; index++) {
       if (!strcmp(testWord, words[index].text)) {
-         matchIndex = index;
+         match_index = index;
          break;
       }
    }
-   return matchIndex;
+   return match_index;
 }
 
-int word_count(char *input_text, WordCount_Word_t words[MAX_WORDS])
+int word_count(char *input_text, word_count_word_t words[MAX_WORDS])
 {
    int index;
-   int uniqueWords = 0;
-   char *testWord;
-   char *lowerCaseInputText;    // hold lowercase copy of passed text
+   int unique_words = 0;
+   char *test_word;
+   char *lower_case_input_text; // hold lowercase copy of passed text
    const char *delimiters = " ,.-\n:!!&@$%^&\"";
 
    // convert the input text to lower case
-   lowerCaseInputText = malloc(strlen(input_text) + 1);
+   lower_case_input_text = malloc(strlen(input_text) + 1);
    for (index = 0; input_text[index] != 0; index++) {
-      lowerCaseInputText[index] = tolower(input_text[index]);
+      lower_case_input_text[index] = tolower(input_text[index]);
    }
-   lowerCaseInputText[index] = '\0';
+   lower_case_input_text[index] = '\0';
 
    // start with known results...
-   memset(words, 0, sizeof(WordCount_Word_t));
+   memset(words, 0, sizeof(word_count_word_t));
 
-   testWord = strtok(lowerCaseInputText, delimiters);
-   while (testWord != NULL) {
+   test_word = strtok(lower_case_input_text, delimiters);
+   while (test_word != NULL) {
       // account for leading/trailing single quote.
-      if (('\'' == testWord[0]) && ('\'' == testWord[strlen(testWord) - 1])) {
-         testWord[strlen(testWord) - 1] = '\0';
-         testWord++;
+      if (('\'' == test_word[0]) && ('\'' == test_word[strlen(test_word) - 1])) {
+         test_word[strlen(test_word) - 1] = '\0';
+         test_word++;
       }
       // determine index of counted word.
-      index = word_match(testWord, uniqueWords, words);
+      index = word_match(test_word, unique_words, words);
 
       // add if not yet counted else increment count.
       if (-1 == index) {
-         words[uniqueWords].count = 1;
-         strcpy(words[uniqueWords].text, testWord);
-         uniqueWords++;
+         words[unique_words].count = 1;
+         strcpy(words[unique_words].text, test_word);
+         unique_words++;
       } else {
          words[index].count++;
       }
       // get next word in string
-      testWord = strtok(NULL, delimiters);
+      test_word = strtok(NULL, delimiters);
    }
 
-   free(lowerCaseInputText);
-   return uniqueWords;
+   free(lower_case_input_text);
+   return unique_words;
 }

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

@@ -5,10 +5,10 @@
 #define MAX_WORD_LENGTH 50      // no individual word will exceed this length
 
 // results structure
-typedef struct WordCount_Word {
+typedef struct word_count_word {
    char text[MAX_WORD_LENGTH];
    int count;
-} WordCount_Word_t;
+} word_count_word_t;
 
 // word_count - routine to classify the unique words and their frequency in a test input string
 // inputs:
@@ -17,6 +17,6 @@ typedef struct WordCount_Word {
 //
 // outputs:
 //    uniqueWords - number of words in the words structure
-int word_count(char *input_text, WordCount_Word_t words[MAX_WORDS]);
+int word_count(char *input_text, word_count_word_t words[MAX_WORDS]);
 
 #endif

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

@@ -4,11 +4,11 @@
 #include "vendor/unity.h"
 #include "../src/word_count.h"
 
-WordCount_Word_t ActualSolution[MAX_WORDS];
+word_count_word_t actual_solution[MAX_WORDS];
 
-static void test_solution(WordCount_Word_t * expected_solution,
+static void test_solution(word_count_word_t * expected_solution,
                           int expected_word_count,
-                          WordCount_Word_t * actual_solution,
+                          word_count_word_t * actual_solution,
                           int actual_word_count)
 {
    // All words counted?
@@ -25,7 +25,7 @@ static void test_solution(WordCount_Word_t * expected_solution,
 
 static void reset_actual_solution(void)
 {
-   memset(ActualSolution, 0, sizeof(ActualSolution));
+   memset(actual_solution, 0, sizeof(actual_solution));
 }
 
 // Tests Start here
@@ -35,21 +35,21 @@ void test_word_count_one_word(void)
    int actual_word_count;
    char *input_text = "word";
    const int expected_word_count = 1;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    // fill in the expected words
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "word", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "word", MAX_WORD_LENGTH);
 
    reset_actual_solution();
 
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_one_of_each_word(void)
@@ -59,26 +59,26 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    // fill in the expected words
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "one", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "of", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "of", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "each", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "each", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_multiple_occurrences_of_a_word(void)
@@ -88,31 +88,31 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "one", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 4;
-   strncpy(ExpectedSolution[index++].text, "fish", MAX_WORD_LENGTH);
+   expected_solution[index].count = 4;
+   strncpy(expected_solution[index++].text, "fish", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "two", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "red", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "red", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "blue", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "blue", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_handles_cramped_lists(void)
@@ -122,25 +122,25 @@ void test_word_count_handles_cramped_lists(void)
    int actual_word_count;
    char *input_text = "one,two,three";
    const int expected_word_count = 3;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "one", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "two", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "three", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_handles_expanded_lists(void)
@@ -150,25 +150,25 @@ void test_word_count_handles_expanded_lists(void)
    int actual_word_count;
    char *input_text = "one,\ntwo,\nthree";
    const int expected_word_count = 3;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "one", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "two", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "three", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_ignore_punctuation(void)
@@ -178,31 +178,31 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "car", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "car", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "carpet", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "carpet", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "as", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "as", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "java", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "java", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "javascript", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "javascript", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_include_numbers(void)
@@ -212,25 +212,25 @@ void test_word_count_include_numbers(void)
    int actual_word_count;
    char *input_text = "testing, 1, 2 testing";
    const int expected_word_count = 3;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 2;
-   strncpy(ExpectedSolution[index++].text, "testing", MAX_WORD_LENGTH);
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "testing", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "1", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "1", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "2", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "2", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_normalize_case(void)
@@ -240,22 +240,22 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 3;
-   strncpy(ExpectedSolution[index++].text, "go", MAX_WORD_LENGTH);
+   expected_solution[index].count = 3;
+   strncpy(expected_solution[index++].text, "go", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 2;
-   strncpy(ExpectedSolution[index++].text, "stop", MAX_WORD_LENGTH);
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "stop", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_with_apostrophes(void)
@@ -265,31 +265,31 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "first", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "first", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 2;
-   strncpy(ExpectedSolution[index++].text, "don't", MAX_WORD_LENGTH);
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "don't", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "laugh", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "laugh", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "then", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "then", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "cry", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "cry", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_with_quotation(void)
@@ -299,34 +299,34 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "joe", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "joe", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "can't", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "can't", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "tell", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "tell", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "between", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "between", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 2;
-   strncpy(ExpectedSolution[index++].text, "large", MAX_WORD_LENGTH);
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "large", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "and", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "and", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 void test_word_count_from_example(void)
@@ -336,28 +336,28 @@ 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;
-   WordCount_Word_t ExpectedSolution[expected_word_count];
+   word_count_word_t expected_solution[expected_word_count];
 
    // build the expected solution
-   memset(ExpectedSolution, 0, sizeof(ExpectedSolution));       // clear to start with a known value
+   memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
-   ExpectedSolution[index].count = 2;
-   strncpy(ExpectedSolution[index++].text, "olly", MAX_WORD_LENGTH);
+   expected_solution[index].count = 2;
+   strncpy(expected_solution[index++].text, "olly", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "in", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "come", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "come", MAX_WORD_LENGTH);
 
-   ExpectedSolution[index].count = 1;
-   strncpy(ExpectedSolution[index++].text, "free", MAX_WORD_LENGTH);
+   expected_solution[index].count = 1;
+   strncpy(expected_solution[index++].text, "free", MAX_WORD_LENGTH);
 
    reset_actual_solution();
-   actual_word_count = word_count(input_text, ActualSolution);
+   actual_word_count = word_count(input_text, actual_solution);
 
-   test_solution(ExpectedSolution,
-                 expected_word_count, ActualSolution, actual_word_count);
+   test_solution(expected_solution,
+                 expected_word_count, actual_solution, actual_word_count);
 }
 
 int main(void)