trackler 2.0.0.3 → 2.0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13d90971009884bd820bdbe76a985c6a084b4a71
-  data.tar.gz: 45d64cda7e36d7934c5fe4827525ff6aa0555eb6
+  metadata.gz: 930373b0c5670419a14e779c478608d57004bd93
+  data.tar.gz: 0f5bd0b92f26975bfa7a090b7b4b16bb4824f52f
 SHA512:
-  metadata.gz: fb8974eb51e067fd796d4cc65ed3fe25df92f865ef5db6b24517036b3121ea31b73c5f62d4b49774c6dcf06b1d6fecbcad776dbb7a68f5d3ac98b4ef83f6fd6c
-  data.tar.gz: fd4f843c2e21324070fab9e4925c40a85901e760d2a557b9e6088758304204328cc3a834fd1c705a72e8c9f76f197fe4f0e35cb87b35727eeb581d0007ecdbce
+  metadata.gz: 626a0ea3510ad74ff08a010e9f3539fb8b9e128a1921953994ffa9755051712c23e123f808300c75d4c1d9e2d7e835d3580e13e23697183ac792c163624e9854
+  data.tar.gz: 961075ac95564c32b9ac6eaf618c2f9765961c06c13caa9d12bbbd6b9458be177fe0105d644e61efab7bc964002358d3f56a85caafbdd9585de19df7c9888c53

data/common/CONTRIBUTING.md

@@ -352,7 +352,7 @@ You can fetch the problem directly using the CLI:
 $ exercism fetch <track_id> <slug>
 ```
 
-Go ahead submit the reference solution that you wrote when creating the problem.
+Go ahead and submit the reference solution that you wrote when creating the problem.
 Remember to archive it if you don't want other people to comment on it.
 
 ## Implementing a Completely New Exercise

data/common/README.md

@@ -46,10 +46,10 @@ mainstream implementation path, this information can also document significant
 variations.
 
 Each test case has the the following keys:
-    description: which will be used to name each generated test
-    'variable names': one or more variable names with values which will be passed to the solution method
-    expected: the expected result (this would be -1 when we expect an exception)
-    msg: a nice message for the failing case
+- description: which will be used to name each generated test
+- 'variable names': one or more variable names with values which will be passed to the solution method
+- expected: the expected result (this would be -1 when we expect an exception)
+- msg: a nice message for the failing case
 
 ## Automated Tests
 

data/common/exercises/bowling/canonical-data.json

@@ -85,6 +85,10 @@
       "description": "two rolls in a frame can not score more than 10 points",
       "rolls": [5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       "expected": -1
+    }, {
+      "description": "bonus roll after a strike in the last frame can not score more than 10 points",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11],
+      "expected": -1
     }, {
       "description": "two bonus rolls after a strike in the last frame can not score more than 10 points",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 6],
@@ -97,6 +101,10 @@
       "description": "the second bonus rolls after a strike in the last frame can not be a strike if the first one is not a strike",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 6, 10],
       "expected": -1
+    }, {
+      "description": "second bonus roll after a strike in the last frame can not score than 10 points",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 11],
+      "expected": -1
     }, {
       "description": "an unstarted game can not be scored",
       "rolls": [],

data/common/exercises/hello-world/description.md

@@ -3,7 +3,7 @@ the traditional first program for beginning programming in a new language.
 
 **Note:** You can skip this exercise by running:
 
-    exercism skip $LANGUAGE hello-world
+    exercism skip $TRACK_ID hello-world
 
 ## Specification
 

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.0.3"
+  VERSION = "2.0.0.4"
 end

data/tracks/c/.gitignore

@@ -2,3 +2,4 @@ bin/configlet
 bin/configlet.exe
 **/*.out
 **/*.o
+.DS_Store

data/tracks/c/bin/run-tests

@@ -1,4 +1,5 @@
 #!/bin/bash
+set -e
 
 for D in exercises/*; do
     CURRENT_DIR=$(pwd)
@@ -26,6 +27,8 @@ for D in exercises/*; do
           make clean >> /dev/null;
           if make | grep FAIL: ; then
             exit 1
+          elif [ ${PIPESTATUS[0]} -ne 0 ]; then
+            exit 1
           fi
           cd ${CURRENT_DIR};
         }

data/tracks/c/config.json

@@ -162,6 +162,15 @@
       "control-flow (loops)",
       "control-flow (if-else statements)"
     ]
+  }, {
+     "difficulty": 1,
+     "slug": "clock",
+     "topics": [
+        "control-flow (if-statements)",
+        "strings",
+        "text formatting",
+        "preprocessor (x-macros in test)"
+     ]
   }],
   "deprecated": [
 

data/tracks/c/exercises/clock/makefile

@@ -0,0 +1,16 @@
+CFLAGS  = -std=c99
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+
+
+test: tests.out
+	@./tests.out
+
+clean:
+	rm -f *.o *.out
+
+tests.out: test/test_clock.c src/clock.c src/clock.h
+	@echo Compiling $@
+	@cc $(CFLAGS) src/clock.c test/vendor/unity.c test/test_clock.c -o tests.out

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

@@ -0,0 +1,11 @@
+#ifndef _CLOCK_H
+#define _CLOCK_H
+
+#define MAX_STR_LEN (5 + 1) // "##:##\0"
+
+typedef char time_text_t[MAX_STR_LEN];
+
+void clock(time_text_t time_text, int hour, int minute);
+void clock_add(time_text_t time_text, int minute_offset);
+
+#endif

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

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include "clock.h"
+
+static void normalize_clock(int *hour, int *minute)
+{
+   while (*minute < 0) {
+      *minute += 60;
+      *hour -= 1;
+   }
+   *hour += *minute / 60;
+   while (*hour < 0) {
+      *hour += 24;
+   }
+   *hour %= 24;
+   *minute %= 60;
+}
+
+void clock(time_text_t time_text, int hour, int minute)
+{
+   normalize_clock(&hour, &minute);
+   sprintf(time_text, "%02d:%02d", hour, minute);
+}
+
+void clock_add(time_text_t time_text, int minute_offset)
+{
+   int hour;
+   int minute;
+   sscanf(time_text, "%02d:%02d", &hour, &minute);
+   minute += minute_offset;
+   clock(time_text, hour, minute);
+}

data/tracks/c/exercises/clock/test/test_clock.c

@@ -0,0 +1,489 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vendor/unity.h"
+#include "../src/clock.h"
+
+time_text_t actual_time_text;
+time_text_t actual_time_text2;
+
+// general routines that test expected results
+void test_expected_value(const char *expected_clock_text, int hour, int minute)
+{
+   memset(actual_time_text, '\0', sizeof(actual_time_text));
+   clock(actual_time_text, hour, minute);
+   TEST_ASSERT_EQUAL_STRING(expected_clock_text, actual_time_text);
+}
+
+void test_time_add_expected_value(const char *expected_clock_text, int hour,
+                                  int minute, int minute_offset)
+{
+   memset(actual_time_text, '\0', sizeof(actual_time_text));
+   clock(actual_time_text, hour, minute);
+   clock_add(actual_time_text, minute_offset);
+
+   TEST_ASSERT_EQUAL_STRING(expected_clock_text, actual_time_text);
+}
+
+void test_time_expected_equality(int hour1, int minute1, int hour2, int minute2,
+                                 bool expected_equality)
+{
+   memset(actual_time_text, '\0', sizeof(actual_time_text));
+   memset(actual_time_text2, '\0', sizeof(actual_time_text2));
+
+   clock(actual_time_text, hour1, minute1);
+   clock(actual_time_text2, hour2, minute2);
+
+   if (expected_equality) {
+      TEST_ASSERT_EQUAL_STRING(actual_time_text, actual_time_text2);
+   } else {
+      bool result = (0 == strcmp(actual_time_text, actual_time_text2));
+
+      TEST_ASSERT_EQUAL(0, result);
+   }
+}
+
+// the tests
+void test_on_the_hour(void)
+{
+   int hour = 8;
+   int minute = 0;
+   char *expected_clock_text = "08:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_past_the_hour(void)
+{
+   int hour = 11;
+   int minute = 9;
+   char *expected_clock_text = "11:09";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_midnight_is_zero_hours(void)
+{
+   int hour = 24;
+   int minute = 0;
+   char *expected_clock_text = "00:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_hour_rolls_over(void)
+{
+   int hour = 25;
+   int minute = 0;
+   char *expected_clock_text = "01:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_hour_rolls_over_continuously(void)
+{
+   int hour = 100;
+   int minute = 0;
+   char *expected_clock_text = "04:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_sixty_minutes_is_next_hour(void)
+{
+   int hour = 1;
+   int minute = 60;
+   char *expected_clock_text = "02:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_minutes_roll_over(void)
+{
+   int hour = 0;
+   int minute = 160;
+   char *expected_clock_text = "02:40";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_minutes_roll_over_continuously(void)
+{
+   int hour = 0;
+   int minute = 1723;
+   char *expected_clock_text = "04:43";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_hour_and_minutes_roll_over(void)
+{
+   int hour = 25;
+   int minute = 160;
+   char *expected_clock_text = "03:40";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_hour_and_minutes_roll_over_continuously(void)
+{
+   int hour = 201;
+   int minute = 3001;
+   char *expected_clock_text = "11:01";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_hour_and_minutes_roll_over_to_exactly_midnight(void)
+{
+   int hour = 72;
+   int minute = 8640;
+   char *expected_clock_text = "00:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_hour(void)
+{
+   int hour = -1;
+   int minute = 15;
+   char *expected_clock_text = "23:15";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_hour_rolls_over(void)
+{
+   int hour = -25;
+   int minute = 0;
+   char *expected_clock_text = "23:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_hour_rolls_over_continuously(void)
+{
+   int hour = -91;
+   int minute = 0;
+   char *expected_clock_text = "05:00";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_minutes(void)
+{
+   int hour = 1;
+   int minute = -40;
+   char *expected_clock_text = "00:20";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_minutes_roll_over(void)
+{
+   int hour = 1;
+   int minute = -160;
+   char *expected_clock_text = "22:20";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_minutes_roll_over_continuously(void)
+{
+   int hour = 1;
+   int minute = -4820;
+   char *expected_clock_text = "16:40";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_hour_and_minutes_both_roll_over(void)
+{
+   int hour = -25;
+   int minute = -160;
+   char *expected_clock_text = "20:20";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_negative_hour_and_minutes_both_roll_over_continuously(void)
+{
+   int hour = -121;
+   int minute = -5810;
+   char *expected_clock_text = "22:10";
+
+   test_expected_value(expected_clock_text, hour, minute);
+}
+
+void test_add_minutes(void)
+{
+   int hour = 10;
+   int minute = 0;
+   int minute_offset = 3;
+   char *expected_clock_text = "10:03";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_no_minutes(void)
+{
+   int hour = 6;
+   int minute = 41;
+   int minute_offset = 0;
+   char *expected_clock_text = "06:41";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_to_next_hour(void)
+{
+   int hour = 0;
+   int minute = 45;
+   int minute_offset = 40;
+   char *expected_clock_text = "01:25";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_more_than_one_hour(void)
+{
+   int hour = 10;
+   int minute = 0;
+   int minute_offset = 61;
+   char *expected_clock_text = "11:01";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_more_than_two_hours_with_carry(void)
+{
+   int hour = 0;
+   int minute = 45;
+   int minute_offset = 160;
+   char *expected_clock_text = "03:25";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_across_midnight(void)
+{
+   int hour = 23;
+   int minute = 59;
+   int minute_offset = 2;
+   char *expected_clock_text = "00:01";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_more_than_one_day(void)
+{
+   int hour = 5;
+   int minute = 32;
+   int minute_offset = 1500;
+   char *expected_clock_text = "06:32";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_add_more_than_two_days(void)
+{
+   int hour = 1;
+   int minute = 1;
+   int minute_offset = 3500;
+   char *expected_clock_text = "11:21";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_minutes(void)
+{
+   int hour = 10;
+   int minute = 3;
+   int minute_offset = -3;
+   char *expected_clock_text = "10:00";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_to_previous_hour(void)
+{
+   int hour = 10;
+   int minute = 3;
+   int minute_offset = -30;
+   char *expected_clock_text = "09:33";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_more_than_an_hour(void)
+{
+   int hour = 10;
+   int minute = 3;
+   int minute_offset = -70;
+   char *expected_clock_text = "08:53";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_across_midnight(void)
+{
+   int hour = 0;
+   int minute = 3;
+   int minute_offset = -4;
+   char *expected_clock_text = "23:59";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_more_than_two_hours(void)
+{
+   int hour = 0;
+   int minute = 0;
+   int minute_offset = -160;
+   char *expected_clock_text = "21:20";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_more_than_two_hours_with_borrow(void)
+{
+   int hour = 6;
+   int minute = 15;
+   int minute_offset = -160;
+   char *expected_clock_text = "03:35";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_more_than_one_day(void)
+{
+   int hour = 5;
+   int minute = 32;
+   int minute_offset = -1500;
+   char *expected_clock_text = "04:32";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+void test_subtract_more_than_two_days(void)
+{
+   int hour = 2;
+   int minute = 20;
+   int minute_offset = -3000;
+   char *expected_clock_text = "00:20";
+
+   test_time_add_expected_value(expected_clock_text, hour, minute,
+                                minute_offset);
+}
+
+// these tests check equality.
+// Part of standard test collection
+// Included even though they don't make much sense in C
+
+// // trying it with XMACROS !
+#define EXPAND_EQUALITY_TEST_AS_TEST(test_name, hour1, minute1, hour2, minute2, expected_equality)\
+   void test_name(void)\
+   {\
+   test_time_expected_equality(hour1, minute1, hour2, minute2, expected_equality);\
+   }\
+
+// below expands to multiple routines...that are all designed to test the equality of 2 different
+// clock representations to see if they are the same or not
+// that 2 clocks are equal...
+// the fields are:
+//    test name, time1_hour, time1_minute, time2_hour, time2_minute, (time1 == time2)
+
+#define EQUALITY_TESTS(ENTRY) \
+   ENTRY(test_clocks_with_same_time,      15,   37,   15, 37, true)\
+   ENTRY(test_clocks_a_minute_apart,      15,   36,   15, 37, false)\
+   ENTRY(test_clocks_an_hour_apart,       15,   37,   14, 37, false)\
+   ENTRY(test_clocks_with_hour_overflow,  10,   37,   34, 37, true)\
+   ENTRY(test_clocks_with_hour_overflow_by_several_days,  3,   11,   99, 11, true)\
+   ENTRY(test_clocks_with_negative_hour,  22,   40,   -2, 40, true)\
+   ENTRY(test_clocks_with_negative_hour_that_wraps,  17,   3,   -31, 3, true)\
+   ENTRY(test_clocks_with_negative_hour_that_wraps_multiple_times,  13,   49, -83, 49, true)\
+   ENTRY(test_clocks_with_minute_overflow,  0,  1,   0, 1441, true)\
+   ENTRY(test_clocks_with_minute_overflow_by_several_days,  2,  2,   2, 4322, true)\
+   ENTRY(test_clocks_with_negative_minute,  2,  40,   3, -20, true)\
+   ENTRY(test_clocks_with_negative_minute_that_wraps,  4,  10,   5, -1490, true)\
+   ENTRY(test_clocks_with_negative_minute_that_wraps_multiple_times,  6,  15,   6, -4305, true)\
+   ENTRY(test_clocks_with_negative_hours_and_minutes,  7,  32,   -12, -268, true)\
+   ENTRY(test_clocks_with_negative_hours_and_minutes_that_wrap,  18,  7,   -54, -11513, true)\
+
+EQUALITY_TESTS(EXPAND_EQUALITY_TEST_AS_TEST)
+
+int main(void)
+{
+   UnityBegin("clock.c");
+
+   RUN_TEST(test_on_the_hour);
+   RUN_TEST(test_past_the_hour);
+   RUN_TEST(test_midnight_is_zero_hours);
+   RUN_TEST(test_hour_rolls_over);
+   RUN_TEST(test_hour_rolls_over_continuously);
+   RUN_TEST(test_sixty_minutes_is_next_hour);
+   RUN_TEST(test_minutes_roll_over);
+   RUN_TEST(test_minutes_roll_over_continuously);
+   RUN_TEST(test_hour_and_minutes_roll_over);
+   RUN_TEST(test_hour_and_minutes_roll_over_continuously);
+   RUN_TEST(test_hour_and_minutes_roll_over_to_exactly_midnight);
+   RUN_TEST(test_negative_hour);
+   RUN_TEST(test_negative_hour_rolls_over);
+   RUN_TEST(test_negative_hour_rolls_over_continuously);
+   RUN_TEST(test_negative_minutes);
+   RUN_TEST(test_negative_minutes_roll_over);
+   RUN_TEST(test_negative_minutes_roll_over_continuously);
+   RUN_TEST(test_negative_hour_and_minutes_both_roll_over);
+   RUN_TEST(test_negative_hour_and_minutes_both_roll_over_continuously);
+   RUN_TEST(test_add_minutes);
+   RUN_TEST(test_add_no_minutes);
+   RUN_TEST(test_add_to_next_hour);
+   RUN_TEST(test_add_more_than_one_hour);
+   RUN_TEST(test_add_more_than_two_hours_with_carry);
+   RUN_TEST(test_add_across_midnight);
+   RUN_TEST(test_add_more_than_one_day);
+   RUN_TEST(test_add_more_than_two_days);
+   RUN_TEST(test_subtract_minutes);
+   RUN_TEST(test_subtract_to_previous_hour);
+   RUN_TEST(test_subtract_more_than_an_hour);
+   RUN_TEST(test_subtract_across_midnight);
+   RUN_TEST(test_subtract_more_than_two_hours);
+   RUN_TEST(test_subtract_more_than_two_hours_with_borrow);
+   RUN_TEST(test_subtract_more_than_one_day);
+   RUN_TEST(test_subtract_more_than_two_days);
+
+   RUN_TEST(test_clocks_with_same_time);
+   RUN_TEST(test_clocks_a_minute_apart);
+   RUN_TEST(test_clocks_an_hour_apart);
+   RUN_TEST(test_clocks_with_hour_overflow);
+   RUN_TEST(test_clocks_with_hour_overflow_by_several_days);
+   RUN_TEST(test_clocks_with_negative_hour);
+   RUN_TEST(test_clocks_with_negative_hour_that_wraps);
+   RUN_TEST(test_clocks_with_negative_hour_that_wraps_multiple_times);
+   RUN_TEST(test_clocks_with_minute_overflow);
+   RUN_TEST(test_clocks_with_minute_overflow_by_several_days);
+   RUN_TEST(test_clocks_with_negative_minute);
+   RUN_TEST(test_clocks_with_negative_minute_that_wraps);
+   RUN_TEST(test_clocks_with_negative_minute_that_wraps_multiple_times);
+   RUN_TEST(test_clocks_with_negative_hours_and_minutes);
+   RUN_TEST(test_clocks_with_negative_hours_and_minutes_that_wrap);
+
+   UnityEnd();
+   return 0;
+}