trackler 2.2.1.46 → 2.2.1.47

data/tracks/c/exercises/leap/test/test_leap.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/leap.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_a_known_leap_year(void)
 {
    TEST_ASSERT_TRUE(is_leap_year(1996));

data/tracks/c/exercises/meetup/test/test_meetup.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/meetup.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_monteenth_of_May_2013(void)
 {
    TEST_ASSERT_EQUAL_INT(13, meetup_day_of_month(2013, 5, "teenth", "Monday"));

data/tracks/c/exercises/nth-prime/test/test_nth_prime.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/nth_prime.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_first_prime(void)
 {
    TEST_ASSERT_EQUAL_UINT32(2, nth(1));

data/tracks/c/exercises/nucleotide-count/test/test_nucleotide_count.c

@@ -3,6 +3,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_strand_count(const char *dna_strand, const char *expected)
 {
    char *actual_count = count(dna_strand);

data/tracks/c/exercises/palindrome-products/test/test_palindrome_products.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/palindrome_products.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_palindromes_list(void)
 {
    product_t product = get_palindrome_product(1, 9);

data/tracks/c/exercises/pangram/test/test_pangram.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/pangram.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_null(void)
 {
    TEST_ASSERT_FALSE(is_pangram(NULL));

data/tracks/c/exercises/pascals-triangle/test/test_pascals_triangle.c

@@ -2,6 +2,14 @@
 #include "../src/pascals_triangle.h"
 #include "vendor/unity.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 static bool check(size_t count, size_t expected[][count], size_t ** result)
 {
    size_t i, j;

data/tracks/c/exercises/perfect-numbers/src/example.c

@@ -17,15 +17,15 @@ static int aliquot_sum(int n)
 
 kind classify_number(int n)
 {
-   kind class = error;
+   kind class = ERROR;
    if (n > 0) {
       int sum = aliquot_sum(n);
       if (sum > n) {
-         class = abundant_number;
+         class = ABUNDANT_NUMBER;
       } else if (sum < n) {
-         class = deficient_number;
+         class = DEFICIENT_NUMBER;
       } else {
-         class = perfect_number;
+         class = PERFECT_NUMBER;
       }
    }
    return class;

data/tracks/c/exercises/perfect-numbers/src/example.h

@@ -2,10 +2,10 @@
 #define PERFECT_NUMBERS_H
 
 typedef enum {
-   perfect_number = 1,
-   abundant_number = 2,
-   deficient_number = 3,
-   error = -1
+   PERFECT_NUMBER = 1,
+   ABUNDANT_NUMBER = 2,
+   DEFICIENT_NUMBER = 3,
+   ERROR = -1
 } kind;
 
 kind classify_number(int);

data/tracks/c/exercises/perfect-numbers/src/perfect_numbers.h

@@ -2,10 +2,10 @@
 #define PERFECT_NUMBERS_H
 
 typedef enum {
-   perfect_number = 1,
-   abundant_number = 2,
-   deficient_number = 3,
-   error = -1
+   PERFECT_NUMBER = 1,
+   ABUNDANT_NUMBER = 2,
+   DEFICIENT_NUMBER = 3,
+   ERROR = -1
 } kind;
 
 #endif

data/tracks/c/exercises/perfect-numbers/test/test_perfect_numbers.c

@@ -1,86 +1,95 @@
 #include "vendor/unity.h"
 #include "../src/perfect_numbers.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_smallest_perfect_number_is_classified_correctly(void)
 {
-   TEST_ASSERT_EQUAL(perfect_number, classify_number(6));
+   TEST_ASSERT_EQUAL(PERFECT_NUMBER, classify_number(6));
 }
 
 void test_medium_perfect_number_is_classified_correctly(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   TEST_ASSERT_EQUAL(perfect_number, classify_number(28));
+   TEST_ASSERT_EQUAL(PERFECT_NUMBER, classify_number(28));
 }
 
 void test_large_perfect_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(perfect_number, classify_number(33550336));
+   TEST_ASSERT_EQUAL(PERFECT_NUMBER, classify_number(33550336));
 }
 
 void test_smallest_abundant_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(abundant_number, classify_number(12));
+   TEST_ASSERT_EQUAL(ABUNDANT_NUMBER, classify_number(12));
 }
 
 void test_medium_abundant_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(abundant_number, classify_number(30));
+   TEST_ASSERT_EQUAL(ABUNDANT_NUMBER, classify_number(30));
 }
 
 void test_large_abundant_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(abundant_number, classify_number(33550335));
+   TEST_ASSERT_EQUAL(ABUNDANT_NUMBER, classify_number(33550335));
 }
 
 void test_smallest_prime_deficient_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(deficient_number, classify_number(2));
+   TEST_ASSERT_EQUAL(DEFICIENT_NUMBER, classify_number(2));
 }
 
 void test_smallest_non_prime_deficient_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(deficient_number, classify_number(4));
+   TEST_ASSERT_EQUAL(DEFICIENT_NUMBER, classify_number(4));
 }
 
 void test_medium_deficient_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(deficient_number, classify_number(32));
+   TEST_ASSERT_EQUAL(DEFICIENT_NUMBER, classify_number(32));
 }
 
 void test_large_deficient_number_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(deficient_number, classify_number(33550337));
+   TEST_ASSERT_EQUAL(DEFICIENT_NUMBER, classify_number(33550337));
 }
 
 void test_edge_case_is_classified_correctly(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(deficient_number, classify_number(1));
+   TEST_ASSERT_EQUAL(DEFICIENT_NUMBER, classify_number(1));
 }
 
 void test_zero_is_rejected(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(error, classify_number(0));
+   TEST_ASSERT_EQUAL(ERROR, classify_number(0));
 }
 
 void test_negative_integer_is_rejected(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_EQUAL(error, classify_number(-1));
+   TEST_ASSERT_EQUAL(ERROR, classify_number(-1));
 }
 
 int main(void)
 {
    UnityBegin("test/test_perfect_numbers.c");
+
    RUN_TEST(test_smallest_perfect_number_is_classified_correctly);
    RUN_TEST(test_medium_perfect_number_is_classified_correctly);
    RUN_TEST(test_large_perfect_number_is_classified_correctly);
@@ -94,6 +103,7 @@ int main(void)
    RUN_TEST(test_edge_case_is_classified_correctly);
    RUN_TEST(test_zero_is_rejected);
    RUN_TEST(test_negative_integer_is_rejected);
+
    UnityEnd();
    return 0;
 }

data/tracks/c/exercises/phone-number/test/test_phone_number.c

@@ -2,6 +2,14 @@
 #include "../src/phone_number.h"
 #include <stdlib.h>
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_phone_number_clean(const char *input, const char *expected)
 {
    char *result = phone_number_clean(input);

data/tracks/c/exercises/raindrops/test/test_raindrops.c

@@ -3,7 +3,11 @@
 
 #define BUFFER_LENGTH 100
 
-void resetTest(void)
+void setUp(void)
+{
+}
+
+void tearDown(void)
 {
 }
 

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

@@ -2,9 +2,9 @@
 #include "react.h"
 
 enum cell_kind {
-   kind_input,
-   kind_compute1,
-   kind_compute2,
+   KIND_INPUT,
+   KIND_COMPUTE_1,
+   KIND_COMPUTE_2,
 };
 
 struct child {
@@ -111,7 +111,7 @@ struct cell *create_input_cell(struct reactor *r, int initial_value)
       free(c);
       return NULL;
    }
-   c->kind = kind_input;
+   c->kind = KIND_INPUT;
    c->value = initial_value;
    return c;
 }
@@ -128,7 +128,7 @@ struct cell *create_compute1_cell(struct reactor *r, struct cell *input,
       free(c);
       return NULL;
    }
-   c->kind = kind_compute1;
+   c->kind = KIND_COMPUTE_1;
    c->input1 = input;
    c->compute1 = compute;
    c->value = compute(get_cell_value(input));
@@ -153,7 +153,7 @@ struct cell *create_compute2_cell(struct reactor *r, struct cell *input1,
       free(c);
       return NULL;
    }
-   c->kind = kind_compute2;
+   c->kind = KIND_COMPUTE_2;
    c->input1 = input1;
    c->input2 = input2;
    c->compute2 = compute;
@@ -173,10 +173,10 @@ static void propagate(struct cell *c)
 {
    int new_value;
    switch (c->kind) {
-   case kind_compute1:
+   case KIND_COMPUTE_1:
       new_value = c->compute1(get_cell_value(c->input1));
       break;
-   case kind_compute2:
+   case KIND_COMPUTE_2:
       new_value =
           c->compute2(get_cell_value(c->input1), get_cell_value(c->input2));
       break;

data/tracks/c/exercises/react/test/test_react.c

@@ -3,6 +3,14 @@
 #include "vendor/unity.h"
 #include "../src/react.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_input_cells_have_value(void)
 {
    struct reactor *r = create_reactor();

data/tracks/c/exercises/rna-transcription/test/test_rna_transcription.c

@@ -2,6 +2,14 @@
 #include "../src/rna_transcription.h"
 #include <stdlib.h>
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_transcription(const char *dna, const char *expected)
 {
    char *rna = to_rna(dna);

data/tracks/c/exercises/robot-simulator/src/example.c

@@ -4,45 +4,45 @@
 robot_grid_status_t robot_init(void)
 {
    return (robot_init_with_position
-           (default_bearing, default_x_coordinate, default_y_coordinate));
+           (DEFAULT_BEARING, DEFAULT_X_COORDINATE, DEFAULT_Y_COORDINATE));
 }
 
 robot_grid_status_t robot_init_with_position(int bearing, int x, int y)
 {
    robot_grid_status_t robot = { bearing, {x, y} };
 
-   if ((bearing < heading_north) || (bearing >= heading_max)) {
-      robot.bearing = default_bearing;
+   if ((bearing < HEADING_NORTH) || (bearing >= HEADING_MAX)) {
+      robot.bearing = DEFAULT_BEARING;
    }
    return robot;
 }
 
 void robot_turn_right(robot_grid_status_t * robot)
 {
-   robot->bearing = (robot->bearing + 1) % heading_max;
+   robot->bearing = (robot->bearing + 1) % HEADING_MAX;
 }
 
 void robot_turn_left(robot_grid_status_t * robot)
 {
-   robot->bearing = ((robot->bearing - 1) + heading_max) % heading_max;
+   robot->bearing = ((robot->bearing - 1) + HEADING_MAX) % HEADING_MAX;
 }
 
 void robot_advance(robot_grid_status_t * robot)
 {
    switch (robot->bearing) {
-   case heading_north:
+   case HEADING_NORTH:
       robot->grid.y_position++;
       break;
 
-   case heading_east:
+   case HEADING_EAST:
       robot->grid.x_position++;
       break;
 
-   case heading_south:
+   case HEADING_SOUTH:
       robot->grid.y_position--;
       break;
 
-   case heading_west:
+   case HEADING_WEST:
       robot->grid.x_position--;
       break;
 
@@ -55,15 +55,15 @@ void robot_simulator(robot_grid_status_t * robot, const char *commands)
 {
    for (unsigned long index = 0; index < strlen(commands); index++) {
       switch (commands[index]) {
-      case command_left:
+      case COMMAND_LEFT:
          robot_turn_left(robot);
          break;
 
-      case command_right:
+      case COMMAND_RIGHT:
          robot_turn_right(robot);
          break;
 
-      case command_advance:
+      case COMMAND_ADVANCE:
          robot_advance(robot);
          break;