trackler 1.0.1.0 → 1.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5df79b2829329101c3131df1e1e3c55750ec5d44
-  data.tar.gz: 3312337a6c8201dab2e6e9fb2f49251ed335bce3
+  metadata.gz: 9afe3a2389f45df29805ba631f6e4c4afc5c66ef
+  data.tar.gz: bebab04f762c5ee338b0e5a4d645985db6b5034b
 SHA512:
-  metadata.gz: 6bad132c234e35b53d232967dfb4f89bdadf921006cc552b9a2065d56065f5aef9e3da3617fc1a2a52b5800a1deb5326d86a6df6e2a5ce296673f8facda6b9ea
-  data.tar.gz: 1c3046428aaa9d6cf4e1b969701b226ff42a255b621549dc7991213e2e36554ae7f4293e0204b801c1bcd11a364eec7be4bd1528d7f1b8ad27bee15fd549bc95
+  metadata.gz: 744116cb977fbed40d585e95a734cedf12e60c2277a703826e39e74e4525881333fed0ca7e4cc3d3add5432df76b6a681bf2c12c3ae7f2223c0bb83313cfd6fd
+  data.tar.gz: 3932ddf8a13ac14ab7e0c0c4baaccb9cf15f7e0b4278d3411c34c07523dae0d07ff397d474a2c0e2904c71b6add9887d8c4f30d6882b6839dd1824f007c91688

data/CHANGELOG.md

@@ -13,6 +13,7 @@ The changelog will not be updated for content updates.
 ----------------
 
 ## Next Release
+* Add script to update submodules and bump version
 * **Your contribution here**
 
 ## v1.0.1.0 (2016-10-16)

data/bin/bump-content

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+system("bin/update")
+
+file = File.absolute_path("../../lib/trackler/version.rb", __FILE__)
+
+contents = File.read(file)
+major, minor, patch, data = contents[/\ \ VERSION\ =\ "(.*)"/, 1].split(".")
+
+version = [major, minor, patch, data.to_i + 1].join(".")
+
+template = <<-TEMPLATE % version
+module Trackler
+  VERSION = "%s"
+end
+TEMPLATE
+
+File.open(file, "w") do |f|
+  f.puts template
+end
+
+cmds = [
+  "git add lib/trackler/version.rb",
+  "git commit -m 'Bump to v%s'" % version,
+  "git tag v%s" % version,
+  "git push origin master",
+  "git push --tags",
+  "gem build trackler.gemspec",
+  "gem install --local trackler-%s.gem" % version,
+  "gem push trackler-%s.gem" % version,
+].each do |cmd|
+  system cmd
+end

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

@@ -1,117 +1,118 @@
 {
   "#": [
-    "Bowling is game where players roll a heavy ball to knock down pins",
-    "arranged in a triangle. Write code to keep track of the score of a",
-    "game of bowling."
+    "Students should implement roll and score methods.",
+    "Roll should accept a single integer.",
+    "Score should return the game's final score, when possible",
+    "For brevity the tests display all the rolls in an array;",
+    "each element of the rolls array should be passed to the roll method",
+    "The final tests define situations where the score can not be returned",
+    "The expection for these tests is -1, indicating an error",
+    "In these cases you should expect an error as is idiomatic for your language",
+    "When to error is also left up to your implementation. There are two options",
+    "  - Error as soon as an invalid roll is made",
+    "  - Error when scoring a game with an invalid roll",
+    "You can also error in both cases."
   ],
-  "methods": {
-    "description": [
-      "Check the public API is correct."
-    ],
-    "cases": [{
-      "description": "must be able to roll with a number of pins",
-      "method": "roll",
-      "arity": 1
-    }, {
-      "description": "must have a score",
-      "method": "score",
-      "arity": 0
-    }]
-  },
   "score": {
     "description": [
-      "Check game can be scored correctly."
+      "Returns the final score of a bowling game"
     ],
     "cases": [{
-      "description": "should be able to score open frame",
-      "rolls": [3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 7
-    }, {
-      "description": "should be able to score multiple frames",
-      "rolls": [3, 4, 2, 3, 5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 19
-    }, {
-      "description": "should be able to score a game with all gutterballs",
+      "description": "should be able to score a game with all zeros",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       "expected": 0
     }, {
-      "description": "should be able to score a game with all single pin rolls",
-      "rolls": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
-      "expected": 20
-    }, {
-      "description": "should be able to score a game with all open frames",
+      "description": "should be able to score a game with no strikes or spares",
       "rolls": [3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6],
       "expected": 90
     }, {
-      "description": "should be able to score a strike not in the last frame",
+      "description": "a spare followed by zeros is worth ten points",
+      "rolls": [6, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": 10
+    }, {
+      "description": "points scored in the roll after a spare are counted twice",
+      "rolls": [6, 4, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": 16
+    }, {
+      "description": "consecutive spares each get a one roll bonus",
+      "rolls": [5, 5, 3, 7, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": 31
+    }, {
+      "description": "a spare in the last frame gets a one roll bonus that is counted once",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 7],
+      "expected": 17
+    }, {
+      "description": "a strike earns ten points in frame with a single roll",
+      "rolls": [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": 10
+    }, {
+      "description": "points scored in the two rolls after a strike are counted twice as a bonus",
       "rolls": [10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       "expected": 26
     }, {
-      "description": "should be able to score a spare not in the last frame",
-      "rolls": [5, 5, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 20
-    }, {
-      "description": "should be able to score multiple strikes in a row",
+      "description": "consecutive strikes each get the two roll bonus",
       "rolls": [10, 10, 10, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       "expected": 81
     }, {
-      "description": "should be able to score multiple spares in a row",
-      "rolls": [5, 5, 3, 7, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": 32
-    }, {
-      "description": "should allow fill balls when the last frame is a strike",
+      "description": "a strike in the last frame gets a two roll bonus that is counted once",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 1],
       "expected": 18
     }, {
-      "description": "should allow fill ball when the last frame is a spare",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 1, 7],
-      "expected": 17
+      "description": "rolling a spare with the two roll bonus does not get a bonus roll",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 7, 3],
+      "expected": 20
     }, {
-      "description": "should allow fill balls to be a strike",
+      "description": "strikes with the two roll bonus do not get bonus rolls",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 10],
       "expected": 30
     }, {
-      "description": "should be able to score a perfect game",
+      "description": "a strike with the one roll bonus after a spare in the last frame does not get a bonus",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 10],
+      "expected": 20
+    }, {
+      "description": "all strikes is a perfect game",
       "rolls": [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
       "expected": 300
-    }]
-  },
-  "validations": {
-    "description": [
-      "Check game rules."
-    ],
-    "cases": [{
-      "description": "should not allow rolls with negative pins",
-      "rolls": [-1],
-      "expected": "Pins must have a value from 0 to 10"
     }, {
-      "description": "should not allow rolls better than strike",
-      "rolls": [11],
-      "expected": "Pins must have a value from 0 to 10"
+      "description": "Rolls can not score negative points",
+      "rolls": [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": -1
     }, {
-      "description": "should not allow two normal rolls better than strike",
-      "rolls": [5, 6],
-      "expected": "Pin count exceeds pins on the lane"
+      "description": "A roll can not score more than 10 points",
+      "rolls": [11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "expected": -1
     }, {
-      "description": "should not allow two normal rolls better than strike in last frame",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6],
-      "expected": "Pin count exceeds pins on the lane"
+      "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": "should not allow to take score at the beginning of the game",
+      "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],
+      "expected": -1
+    }, {
+      "description": "An unstarted game can not be scored",
       "rolls": [],
-      "expected": "Score cannot be taken until the end of the game"
+      "expected": -1
     }, {
-      "description": "should not allow to take score before the game has ended",
-      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": "Score cannot be taken until the end of the game"
+      "description": "An incomplete game can not be scored",
+      "rolls": [0, 0],
+      "expected": -1
     }, {
-      "description": "should not allow rolls after the tenth frame",
+      "description": "A game with more than ten frames can not be scored",
       "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-      "expected": "Should not be able to roll after game is over"
+      "expected": -1
+    }, {
+      "description": "bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10],
+      "expected": -1
+    }, {
+      "description": "both bonus rolls for a strike in the last frame must be rolled before score can be calculated",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10],
+      "expected": -1
     }, {
-      "description": "should not calculate score before fill balls have been played",
-      "rolls": [10, 10, 10, 10, 10, 10, 10, 10, 10, 10],
-      "expected": "Score cannot be taken until the end of the game"
+      "description": "bonus roll for a spare in the last frame must be rolled before score can be calculated",
+      "rolls": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3],
+      "expected": -1
     }]
   }
 }

data/common/exercises/counter/.deprecated

@@ -0,0 +1 @@
+**NOTE: This exercise has been deprecated.**

data/common/exercises/point-mutations/.deprecated

@@ -0,0 +1 @@
+**NOTE: This exercise has been deprecated.**

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

@@ -0,0 +1,83 @@
+{
+    "#": [
+        "Here -1 is used as expected value to indicate that the",
+        "input value is out of the range described in the exercise."
+    ],
+    "cases": [
+        {
+            "description": "zero",
+            "input": 0,
+            "expected": "zero"
+        },
+        {
+            "description": "one",
+            "input": 1,
+            "expected": "one"
+        },
+        {
+            "description": "fourteen",
+            "input": 14,
+            "expected": "fourteen"
+        },
+        {
+            "description": "twenty",
+            "input": 20,
+            "expected": "twenty"
+        },
+        {
+            "description": "twenty-two",
+            "input": 22,
+            "expected": "twenty-two"
+        },
+        {
+            "description": "one hundred",
+            "input": 100,
+            "expected": "one hundred"
+        },
+        {
+            "description": "one hundred twenty-three",
+            "input": 123,
+            "expected": "one hundred twenty-three"
+        },
+        {
+            "description": "one thousand",
+            "input": 1000,
+            "expected": "one thousand"
+        },
+        {
+            "description": "one thousand two hundred thirty-four",
+            "input": 1234,
+            "expected": "one thousand two hundred thirty-four"
+        },
+        {
+            "description": "one million",
+            "input": 1000000,
+            "expected": "one million"
+        },
+        {
+            "description": "one million two thousand three hundred forty-five",
+            "input": 1002345,
+            "expected": "one million two thousand three hundred forty-five"
+        },
+        {
+            "description": "one billion",
+            "input": 1000000000,
+            "expected": "one billion"
+        },
+        {
+            "description": "a big number",
+            "input": 987654321123,
+            "expected": "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three"
+        },
+        {
+            "description": "numbers below zero are out of range",
+            "input": -1,
+            "expected": -1
+        },
+        {
+            "description": "numbers above 999,999,999,999 are out of range",
+            "input": 1000000000000,
+            "expected": -1
+        }
+    ]
+}

data/common/exercises/word-count/canonical-data.json

@@ -13,22 +13,42 @@
         {
             "description": "multiple occurrences of a word",
             "input": "one fish two fish red fish blue fish",
-            "expected": { "one" : 1, "fish" : 4, "two" : 1, "red" : 1, "blue" : 1 }
+            "expected": { "one": 1, "fish": 4, "two": 1, "red": 1, "blue": 1 }
+        },
+        {
+            "description": "handles cramped lists",
+            "input": "one,two,three",
+            "expected": { "one": 1, "two": 1, "three": 1 }
+        },
+        {
+            "description": "handles expanded lists",
+            "input": "one,\ntwo,\nthree",
+            "expected": { "one": 1, "two": 1, "three": 1 }
         },
         {
             "description": "ignore punctuation",
-            "input": "car : carpet as java : javascript!!&@$%^&",
-            "expected": { "car" : 1, "carpet" : 1, "as" : 1, "java" : 1, "javascript" : 1 }
+            "input": "car: carpet as java: javascript!!&@$%^&",
+            "expected": { "car": 1, "carpet": 1, "as": 1, "java": 1, "javascript": 1 }
         },
         {
             "description": "include numbers",
             "input": "testing, 1, 2 testing",
-            "expected": { "testing" : 2, "1" : 1, "2" : 1 }
+            "expected": { "testing": 2, "1": 1, "2": 1 }
         },
         {
             "description": "normalize case",
             "input": "go Go GO Stop stop",
-            "expected": { "go" : 3, "stop" : 2 }
+            "expected": { "go": 3, "stop": 2 }
+        },
+        {
+            "description": "with apostrophes",
+            "input": "First: don't laugh. Then: don't cry.",
+            "expected": { "first": 1, "don't": 2, "laugh": 1, "then": 1, "cry": 1 }
+        },
+        {
+            "description": "with_quotations",
+            "input": "Joe can't tell between 'large' and large.",
+            "expected": { "joe": 1, "can't": 1, "tell": 1, "between": 1, "large": 2, "and": 1 }
         }
     ]
 }

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "1.0.1.0"
+  VERSION = "1.0.1.1"
 end

data/tracks/c/config.json

@@ -13,6 +13,7 @@
     "raindrops",
     "bob",
     "grains",
+    "largest-series-product",
     "pangram",
     "nth-prime",
     "beer-song",
@@ -81,6 +82,14 @@
       "bitwise operations",
       "performance optimizations"
     ]
+  }, {
+    "difficulty": 5,
+    "slug": "largest-series-product",
+    "topics": [
+      "control-flow (loops)",
+      "strings",
+      "performance optimizations"
+    ]
   }, {
     "difficulty": 3,
     "slug": "pangram",

data/tracks/c/exercises/largest-series-product/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_largest_series_product.c src/largest_series_product.c src/largest_series_product.h
+	@echo Compiling $@
+	@cc $(CFLAGS) src/largest_series_product.c test/vendor/unity.c test/test_largest_series_product.c -o tests.out

data/tracks/c/exercises/largest-series-product/src/example.c

@@ -0,0 +1,54 @@
+#include <string.h>
+#include <stdbool.h>
+#include "largest_series_product.h"
+
+#define MAX(x, y) (x) > (y) ? (x) : (y)
+
+static int to_int(char c)
+{
+   return c - '0';
+}
+
+static bool is_digit(char c)
+{
+   return (c >= '0') && (c <= '9');
+}
+
+int64_t largest_series_product(char *digits, size_t span)
+{
+   size_t digit_count = strlen(digits);
+   size_t zeros = 0;
+   long product = 1;
+   long largest_product = 0;
+
+   if (span > digit_count)
+      return -1;
+
+   if (!span && !digit_count)
+      return 1;
+
+   for (size_t i = 0; i < digit_count; i++) {
+      if (!is_digit(digits[i]))
+         return -1;
+
+      int to_add = to_int(digits[i]);
+
+      if (i >= span) {
+         int to_remove = to_int(digits[i - span]);
+         if (to_remove == 0)
+            zeros--;
+         else
+            product /= to_remove;
+      }
+
+      if (to_add > 0)
+         product *= to_add;
+      else
+         zeros++;
+
+      if ((i + 1 >= span) && (zeros == 0))
+         largest_product = MAX(largest_product, product);
+   }
+
+   return largest_product;
+}

data/tracks/c/exercises/largest-series-product/src/example.h

@@ -0,0 +1,9 @@
+#ifndef _LARGEST_SERIES_PRODUCT_H
+#define _LARGEST_SERIES_PRODUCT_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+int64_t largest_series_product(char *digits, size_t span);
+
+#endif

data/tracks/c/exercises/largest-series-product/test/test_largest_series_product.c

@@ -0,0 +1,114 @@
+#include "vendor/unity.h"
+#include "../src/largest_series_product.h"
+
+void test_can_find_the_largest_product_of_2_with_numbers_in_order(void)
+{
+   TEST_ASSERT_EQUAL(72, largest_series_product("0123456789", 2));
+}
+
+void test_can_find_the_largest_product_of_2(void)
+{
+   TEST_ASSERT_EQUAL(48, largest_series_product("576802143", 2));
+}
+
+void test_finds_the_largest_product_if_span_equals_length(void)
+{
+   TEST_ASSERT_EQUAL(18, largest_series_product("29", 2));
+}
+
+void test_can_find_the_largest_product_of_3_with_numbers_in_order(void)
+{
+   TEST_ASSERT_EQUAL(504, largest_series_product("0123456789", 3));
+}
+
+void test_can_find_the_largest_product_of_3(void)
+{
+   TEST_ASSERT_EQUAL(270, largest_series_product("1027839564", 3));
+}
+
+void test_can_find_the_largest_product_of_5_with_numbers_in_order(void)
+{
+   TEST_ASSERT_EQUAL(15120, largest_series_product("0123456789", 5));
+}
+
+void test_can_get_the_largest_product_of_a_big_number(void)
+{
+   TEST_ASSERT_EQUAL(23520,
+                     largest_series_product
+                     ("73167176531330624919225119674426574742355349194934", 6));
+}
+
+void test_can_get_the_largest_product_of_a_big_number_ii(void)
+{
+   TEST_ASSERT_EQUAL(28350,
+                     largest_series_product
+                     ("52677741234314237566414902593461595376319419139427", 6));
+}
+
+void test_can_get_the_largest_product_of_a_big_number_project_euler(void)
+{
+   TEST_ASSERT_EQUAL_INT64(23514624000,
+                           largest_series_product
+                           ("7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450",
+                           13));
+}
+
+void test_reports_zero_if_the_only_digits_are_zero(void)
+{
+   TEST_ASSERT_EQUAL(0, largest_series_product("0000", 2));
+}
+
+void test_reports_zero_if_all_spans_include_zero(void)
+{
+   TEST_ASSERT_EQUAL(0, largest_series_product("99099", 3));
+}
+
+void test_rejects_span_longer_than_string_length(void)
+{
+   TEST_ASSERT_EQUAL(-1, largest_series_product("123", 4));
+}
+
+void test_reports_1_for_empty_string_and_empty_product_(void)
+{
+   TEST_ASSERT_EQUAL(1, largest_series_product("", 0));
+}
+
+void test_reports_1_for_nonempty_string_and_empty_product_(void)
+{
+   TEST_ASSERT_EQUAL(1, largest_series_product("123", 0));
+}
+
+void test_rejects_empty_string_and_nonzero_span(void)
+{
+   TEST_ASSERT_EQUAL(-1, largest_series_product("", 1));
+}
+
+void test_rejects_invalid_character_in_digits(void)
+{
+   TEST_ASSERT_EQUAL(-1, largest_series_product("123a5", 2));
+}
+
+int main(void)
+{
+   UnityBegin("largest_series_product.c");
+
+   RUN_TEST(test_can_find_the_largest_product_of_2_with_numbers_in_order);
+   RUN_TEST(test_can_find_the_largest_product_of_2);
+   RUN_TEST(test_finds_the_largest_product_if_span_equals_length);
+   RUN_TEST(test_can_find_the_largest_product_of_3_with_numbers_in_order);
+   RUN_TEST(test_can_find_the_largest_product_of_3);
+   RUN_TEST(test_can_find_the_largest_product_of_5_with_numbers_in_order);
+   RUN_TEST(test_can_get_the_largest_product_of_a_big_number);
+   RUN_TEST(test_can_get_the_largest_product_of_a_big_number_ii);
+   RUN_TEST(test_can_get_the_largest_product_of_a_big_number_project_euler);
+   RUN_TEST(test_reports_zero_if_the_only_digits_are_zero);
+   RUN_TEST(test_reports_zero_if_all_spans_include_zero);
+   RUN_TEST(test_rejects_span_longer_than_string_length);
+   RUN_TEST(test_reports_1_for_empty_string_and_empty_product_);
+   RUN_TEST(test_reports_1_for_nonempty_string_and_empty_product_);
+   RUN_TEST(test_rejects_empty_string_and_nonzero_span);
+   RUN_TEST(test_rejects_invalid_character_in_digits);
+
+   UnityEnd();
+   return 0;
+}