trackler 2.2.1.45 → 2.2.1.46

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

@@ -4,20 +4,20 @@
 
 #include "series.h"
 
-SeriesResults_t series(char *inputText, unsigned int substringLength)
+series_results_t series(char *input_text, unsigned int substring_length)
 {
-   int substringCount = strlen(inputText) - (substringLength - 1);
-   SeriesResults_t results;
+   int substring_count = strlen(input_text) - (substring_length - 1);
+   series_results_t results;
 
    memset(&results, 0, sizeof(results));
-   if ((substringCount > 0) && (substringLength > 0)) {
-      results.substringCount = substringCount;
-      results.substring = malloc(sizeof(char *) * substringCount);
-      for (int index = 0; index < substringCount; index++) {
+   if ((substring_count > 0) && (substring_length > 0)) {
+      results.substring_count = substring_count;
+      results.substring = malloc(sizeof(char *) * substring_count);
+      for (int index = 0; index < substring_count; index++) {
          results.substring[index] =
-             malloc(sizeof(char) * (substringLength + 1));
-         sprintf(results.substring[index], "%.*s", substringLength,
-                 &inputText[index]);
+             malloc(sizeof(char) * (substring_length + 1));
+         sprintf(results.substring[index], "%.*s", substring_length,
+                 &input_text[index]);
       }
    }
    return results;

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

@@ -6,10 +6,10 @@
 #define MAX_SERIES_LENGTH (5)
 
 // results structure
-typedef struct SeriesResults {
-   unsigned int substringCount;
-   char **substring;            // array of pointers of dimension substringCount
-} SeriesResults_t;
+typedef struct series_results {
+   unsigned int substring_count;
+   char **substring;            // array of pointers of dimension substring_count
+} series_results_t;
 
 // series - routine to split up input text into consecutive substrings of text of a given substringLength
 //
@@ -23,6 +23,6 @@ typedef struct SeriesResults {
 //
 //       calling routine will free memory associated with each of the substrings and
 //       the pointers to the substrings.
-SeriesResults_t series(char *inputText, unsigned int substringLength);
+series_results_t series(char *input_text, unsigned int substring_length);
 
 #endif

data/tracks/c/exercises/series/test/test_series.c

@@ -3,47 +3,94 @@
 #include "../src/series.h"
 
 // helper routines to validate test results
-static void testSolution(SeriesResults_t * expectedSolution,
-                         SeriesResults_t * actualSolution)
+static void test_solution(series_results_t * expected_solution,
+                          series_results_t * actual_solution)
 {
    // result count correct
-   TEST_ASSERT_EQUAL(expectedSolution->substringCount,
-                     actualSolution->substringCount);
+   TEST_ASSERT_EQUAL(expected_solution->substring_count,
+                     actual_solution->substring_count);
 
    // test each substring...
-   for (unsigned int index = 0; index < expectedSolution->substringCount;
+   for (unsigned int index = 0; index < expected_solution->substring_count;
         index++) {
-      TEST_ASSERT_EQUAL_STRING(expectedSolution->substring[index],
-                               actualSolution->substring[index]);
-      free(actualSolution->substring[index]);
+      TEST_ASSERT_EQUAL_STRING(expected_solution->substring[index],
+                               actual_solution->substring[index]);
+      free(actual_solution->substring[index]);
    }
-   if (actualSolution->substringCount) {
-      free(actualSolution->substring);
+   if (actual_solution->substring_count) {
+      free(actual_solution->substring);
    }
 }
 
-#define EXPAND_SERIES_TEST_CASES_AS_TEST(test_name, inputText, substringLength, expectedResultCount, expectedResultSubstrings)\
-   void test_name(void)\
-   {\
-   char *substrings[] =  expectedResultSubstrings;\
-   SeriesResults_t expected = {expectedResultCount, &substrings[0]};\
-   SeriesResults_t actual = series(inputText, substringLength);\
-   testSolution(&expected, &actual);\
-   }\
+// Test cases
+void test_slices_of_one(void)
+{
+   char *substrings[] = { "0", "1", "2", "3", "4" };
+   series_results_t expected = { 5, &substrings[0] };
+   series_results_t actual = series("01234", 1);
 
-#define ASSEMBLE_STRING_ARRAY(...) __VA_ARGS__
+   test_solution(&expected, &actual);
+}
 
-// Test cases
-#define SERIES_TEST_CASES(ENTRY) \
-   ENTRY(test_slices_of_one, "01234", 1, 5, { ASSEMBLE_STRING_ARRAY("0","1","2","3","4") })\
-   ENTRY(test_slices_of_two, "97867564", 2, 7, { ASSEMBLE_STRING_ARRAY("97","78","86","67","75","56", "64") })\
-   ENTRY(test_slices_of_three, "97867564", 3, 6, { ASSEMBLE_STRING_ARRAY("978","786","867","675","756","564") })\
-   ENTRY(test_slices_of_four, "01234", 4, 2, { ASSEMBLE_STRING_ARRAY("0123","1234") })\
-   ENTRY(test_slices_of_five, "01234", 5, 1, { ASSEMBLE_STRING_ARRAY("01234") })\
-   ENTRY(test_overly_long_slice, "012", 4, 0, { ASSEMBLE_STRING_ARRAY("") })\
-   ENTRY(test_overly_short_slice, "01234", 0, 0, { ASSEMBLE_STRING_ARRAY("") })\
-
-SERIES_TEST_CASES(EXPAND_SERIES_TEST_CASES_AS_TEST)
+void test_slices_of_two(void)
+{
+   TEST_IGNORE();               // delete this line to run test
+   char *substrings[] = { "97", "78", "86", "67", "75", "56", "64" };
+   series_results_t expected = { 7, &substrings[0] };
+   series_results_t actual = series("97867564", 2);
+
+   test_solution(&expected, &actual);
+}
+
+void test_slices_of_three(void)
+{
+   TEST_IGNORE();
+   char *substrings[] = { "978", "786", "867", "675", "756", "564" };
+   series_results_t expected = { 6, &substrings[0] };
+   series_results_t actual = series("97867564", 3);
+
+   test_solution(&expected, &actual);
+}
+
+void test_slices_of_four(void)
+{
+   TEST_IGNORE();
+   char *substrings[] = { "0123", "1234" };
+   series_results_t expected = { 2, &substrings[0] };
+   series_results_t actual = series("01234", 4);
+
+   test_solution(&expected, &actual);
+}
+
+void test_slices_of_five(void)
+{
+   TEST_IGNORE();
+   char *substrings[] = { "01234" };
+   series_results_t expected = { 1, &substrings[0] };
+   series_results_t actual = series("01234", 5);
+
+   test_solution(&expected, &actual);
+}
+
+void test_overly_long_slice(void)
+{
+   TEST_IGNORE();
+   char *substrings[] = { "" };
+   series_results_t expected = { 0, &substrings[0] };
+   series_results_t actual = series("012", 4);
+
+   test_solution(&expected, &actual);
+}
+
+void test_overly_short_slice(void)
+{
+   TEST_IGNORE();
+   char *substrings[] = { "" };
+   series_results_t expected = { 0, &substrings[0] };
+   series_results_t actual = series("01234", 0);
+
+   test_solution(&expected, &actual);
+}
 
 int main(void)
 {

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

@@ -3,49 +3,49 @@
 #include <math.h>
 #include "sieve.h"
 
-unsigned int sieve(const unsigned int limit, primesArray_t primes)
+unsigned int sieve(const unsigned int limit, primes_array_t primes)
 {
-   unsigned int numberOfPrimes = 0;
-   unsigned char *numberIsPrime;
+   unsigned int number_of_primes = 0;
+   unsigned char *number_is_prime;
 
    // clear the results
    memset(primes, 0, sizeof(*primes));
 
    if (limit > 1) {
       //allocate 1 more than limit for convenience so the number and the index are same
-      numberIsPrime = malloc(limit + 1);
-      memset(numberIsPrime, 1, limit + 1);
+      number_is_prime = malloc(limit + 1);
+      memset(number_is_prime, 1, limit + 1);
 
-      unsigned int maxFactor = sqrt(limit) + 1;
+      unsigned int max_factor = sqrt(limit) + 1;
 
       // mark 0 and 1 as not prime
       for (unsigned int i = 0; i < 2; i++) {
-         numberIsPrime[i] = 0;
+         number_is_prime[i] = 0;
       }
 
       // mark the remaining numbers in the array according to the algo.
-      for (unsigned int index = 2; index < maxFactor;) {
+      for (unsigned int index = 2; index < max_factor;) {
          // mark all of multiples that can't be prime
-         for (unsigned int nonPrimeIndex = (2 * index);
-              nonPrimeIndex < (limit + 1); nonPrimeIndex += index) {
-            numberIsPrime[nonPrimeIndex] = 0;
+         for (unsigned int non_prime_index = (2 * index);
+              non_prime_index < (limit + 1); non_prime_index += index) {
+            number_is_prime[non_prime_index] = 0;
          }
 
          // adjust the index
          do {
             index++;
-            if (numberIsPrime[index]) {
+            if (number_is_prime[index]) {
                break;
             }
-         } while (index <= maxFactor);
+         } while (index <= max_factor);
       }
       // collect and count the primes found
       for (unsigned int i = 1; i < limit + 1; i++) {
-         if (numberIsPrime[i]) {
-            primes[numberOfPrimes++] = i;
+         if (number_is_prime[i]) {
+            primes[number_of_primes++] = i;
          }
       }
-      free(numberIsPrime);
+      free(number_is_prime);
    }
-   return numberOfPrimes;
+   return number_of_primes;
 }

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

@@ -3,8 +3,8 @@
 
 #define MAX_LIMIT_TESTED (1000)
 
-typedef unsigned int primesArray_t[MAX_LIMIT_TESTED];
+typedef unsigned int primes_array_t[MAX_LIMIT_TESTED];
 
-unsigned int sieve(const unsigned int limit, primesArray_t primes);
+unsigned int sieve(const unsigned int limit, primes_array_t primes);
 
 #endif

data/tracks/c/exercises/sieve/test/test_sieve.c

@@ -2,12 +2,12 @@
 #include "vendor/unity.h"
 #include "../src/sieve.h"
 
-static primesArray_t result_array;
+static primes_array_t result_array;
 
 void test_no_primes_under_two(void)
 {
    const unsigned int limit = 1;
-   const primesArray_t expected_prime_array = { 0 };
+   const primes_array_t expected_prime_array = { 0 };
    const unsigned int expected_prime_count = 0;
    unsigned int result_prime_count;
 
@@ -24,7 +24,7 @@ void test_find_first_prime(void)
 {
    TEST_IGNORE();               // delete this line to run test
    const unsigned int limit = 2;
-   const primesArray_t expected_prime_array = { 2 };
+   const primes_array_t expected_prime_array = { 2 };
    const unsigned int expected_prime_count = 1;
    unsigned int result_prime_count;
 
@@ -41,7 +41,7 @@ void test_find_primes_up_to_10(void)
 {
    TEST_IGNORE();
    const unsigned int limit = 10;
-   const primesArray_t expected_prime_array = { 2, 3, 5, 7 };
+   const primes_array_t expected_prime_array = { 2, 3, 5, 7 };
    const unsigned int expected_prime_count = 4;
    unsigned int result_prime_count;
 
@@ -58,7 +58,7 @@ void test_limit_is_prime(void)
 {
    TEST_IGNORE();
    const unsigned int limit = 13;
-   const primesArray_t expected_prime_array = { 2, 3, 5, 7, 11, 13 };
+   const primes_array_t expected_prime_array = { 2, 3, 5, 7, 11, 13 };
    const unsigned int expected_prime_count = 6;
    unsigned int result_prime_count;
 
@@ -75,7 +75,7 @@ void test_find_primes_up_to_1000(void)
 {
    TEST_IGNORE();
    const unsigned int limit = 1000;
-   const primesArray_t expected_prime_array = {
+   const primes_array_t expected_prime_array = {
       2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
       61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
       131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,

data/tracks/c/exercises/space-age/src/example.c

@@ -15,7 +15,7 @@ static const float factors[8] = {
    EARTH * 164.79132            // Neptune
 };
 
-float convert_planet_age(Planets planet, const long input)
+float convert_planet_age(planet_t planet, const long input)
 {
    return input / factors[planet];
 }

data/tracks/c/exercises/space-age/src/example.h

@@ -1,7 +1,7 @@
 #ifndef SPACE_AGE_H
 #define SPACE_AGE_H
 
-typedef enum planets {
+typedef enum planet {
    mercury,
    venus,
    earth,
@@ -10,8 +10,8 @@ typedef enum planets {
    saturn,
    uranus,
    neptune,
-} Planets;
+} planet_t;
 
-float convert_planet_age(Planets planet, const long input);
+float convert_planet_age(planet_t planet, const long input);
 
 #endif

data/tracks/c/exercises/space-age/test/test_space_age.c

@@ -51,6 +51,7 @@ void test_convert_neptune_year(void)
 int main(void)
 {
    UnityBegin("test/test_space_age.c");
+
    RUN_TEST(test_convert_earth_year);
    RUN_TEST(test_convert_mercury_year);
    RUN_TEST(test_convert_venus_year);
@@ -59,6 +60,7 @@ int main(void)
    RUN_TEST(test_convert_saturn_year);
    RUN_TEST(test_convert_uranus_year);
    RUN_TEST(test_convert_neptune_year);
+
    UnityEnd();
    return 0;
 }

data/tracks/c/exercises/sum-of-multiples/src/example.c

@@ -6,10 +6,12 @@ unsigned int sum_of_multiples(const unsigned int *multiples,
                               const unsigned int upper_bound)
 {
    unsigned int sum = 0;
+   if (NULL == multiples)
+      return sum;
 
    for (unsigned int current = 1; current < upper_bound; current++) {
       for (size_t i = 0; i < number_of_multiples; i++) {
-         if ((current % multiples[i]) == 0) {
+         if (0 != multiples[i] && (current % multiples[i]) == 0) {
             sum += current;
             break;
          }

data/tracks/c/exercises/sum-of-multiples/test/test_sum_of_multiples.c

@@ -101,12 +101,27 @@ void test_sum_of_multiples_of_1_up_to_100(void)
                                       100));
 }
 
+void test_sum_of_multiples_of_0_up_to_100(void)
+{
+   TEST_IGNORE();
+   const unsigned int multiples[] = { 0 };
+   TEST_ASSERT_EQUAL(0,
+                     sum_of_multiples(multiples, NUM_OF_ELEMENTS(multiples),
+                                      100));
+}
+
 void test_no_multiples_given(void)
 {
    TEST_IGNORE();
    TEST_ASSERT_EQUAL(0, sum_of_multiples(NULL, 0, 10000));
 }
 
+void test_null_ptr_multiple(void)
+{
+   TEST_IGNORE();
+   TEST_ASSERT_EQUAL(0, sum_of_multiples(NULL, 3, 10000));
+}
+
 int main(void)
 {
    UnityBegin("test/test_sum_of_multiples.c");
@@ -122,7 +137,9 @@ int main(void)
    RUN_TEST(test_sum_of_multiples_of_5_and_25_up_to_51);
    RUN_TEST(test_sum_of_multiples_of_43_and_47_up_to_10000);
    RUN_TEST(test_sum_of_multiples_of_1_up_to_100);
+   RUN_TEST(test_sum_of_multiples_of_0_up_to_100);
    RUN_TEST(test_no_multiples_given);
+   RUN_TEST(test_null_ptr_multiple);
 
    UnityEnd();
    return 0;

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

@@ -1,6 +1,6 @@
 #include "triangle.h"
 
-bool triangle_equality(Triangle_t * input)
+bool triangle_equality(triangle_t * input)
 {
    return (input->a < (input->b + input->c)
            && input->b < (input->a + input->c)
@@ -8,7 +8,7 @@ bool triangle_equality(Triangle_t * input)
        );
 }
 
-bool is_equilateral(Triangle_t * input)
+bool is_equilateral(triangle_t * input)
 {
    return (triangle_equality(input)
            && (input->a == input->b)
@@ -16,7 +16,7 @@ bool is_equilateral(Triangle_t * input)
        );
 }
 
-bool is_isosceles(Triangle_t * input)
+bool is_isosceles(triangle_t * input)
 {
    return (triangle_equality(input) && ((input->a == input->b)
                                         || (input->b == input->c)
@@ -24,7 +24,7 @@ bool is_isosceles(Triangle_t * input)
        );
 }
 
-bool is_scalene(Triangle_t * input)
+bool is_scalene(triangle_t * input)
 {
    return (!(is_equilateral(input))
            && !(is_isosceles(input))

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

@@ -6,10 +6,10 @@ typedef struct {
    double a;
    double b;
    double c;
-} Triangle_t;
+} triangle_t;
 
-bool is_equilateral(Triangle_t * input);
-bool is_isosceles(Triangle_t * input);
-bool is_scalene(Triangle_t * input);
+bool is_equilateral(triangle_t * input);
+bool is_isosceles(triangle_t * input);
+bool is_scalene(triangle_t * input);
 
 #endif