trackler 2.2.1.46 → 2.2.1.47

data/tracks/c/exercises/robot-simulator/src/robot_simulator.h

@@ -2,23 +2,23 @@
 #define ROBOT_SIMULATOR_H
 
 typedef enum {
-   heading_north = 0,
-   heading_east,
-   heading_south,
-   heading_west,
-   heading_max
+   HEADING_NORTH = 0,
+   HEADING_EAST,
+   HEADING_SOUTH,
+   HEADING_WEST,
+   HEADING_MAX
 } bearing_t;
 
 enum {
-   default_bearing = heading_north,
-   default_x_coordinate = 0,
-   default_y_coordinate = 0,
+   DEFAULT_BEARING = HEADING_NORTH,
+   DEFAULT_X_COORDINATE = 0,
+   DEFAULT_Y_COORDINATE = 0,
 };
 
 enum {
-   command_left = 'L',
-   command_right = 'R',
-   command_advance = 'A'
+   COMMAND_LEFT = 'L',
+   COMMAND_RIGHT = 'R',
+   COMMAND_ADVANCE = 'A'
 };
 
 typedef struct robot_coordinates {

data/tracks/c/exercises/robot-simulator/test/test_robot_simulator.c

@@ -1,6 +1,14 @@
 #include "../src/robot_simulator.h"
 #include "vendor/unity.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 // Test Helper Function
 void confirm_position(robot_grid_status_t * expected,
                       robot_grid_status_t * actual)
@@ -14,7 +22,7 @@ void confirm_position(robot_grid_status_t * expected,
 void test_init(void)
 {
    robot_grid_status_t expected =
-       { default_bearing, {default_x_coordinate, default_y_coordinate} };
+       { DEFAULT_BEARING, {DEFAULT_X_COORDINATE, DEFAULT_Y_COORDINATE} };
    robot_grid_status_t actual = robot_init();
 
    confirm_position(&expected, &actual);
@@ -24,9 +32,9 @@ void test_invalid_initial_heading(void)
 {
    TEST_IGNORE();               // delete this line to run test
    robot_grid_status_t expected =
-       { default_bearing, {default_x_coordinate, default_y_coordinate} };
+       { DEFAULT_BEARING, {DEFAULT_X_COORDINATE, DEFAULT_Y_COORDINATE} };
    robot_grid_status_t actual =
-       robot_init_with_position(99, default_x_coordinate, default_y_coordinate);
+       robot_init_with_position(99, DEFAULT_X_COORDINATE, DEFAULT_Y_COORDINATE);
 
    confirm_position(&expected, &actual);
 }
@@ -34,8 +42,8 @@ void test_invalid_initial_heading(void)
 void test_init_with_negative_positions(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_south, {-1, -1} };
-   robot_grid_status_t actual = robot_init_with_position(heading_south, -1, -1);
+   robot_grid_status_t expected = { HEADING_SOUTH, {-1, -1} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_SOUTH, -1, -1);
 
    confirm_position(&expected, &actual);
 }
@@ -43,21 +51,21 @@ void test_init_with_negative_positions(void)
 void test_turn_right(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_east, {0, 0} };
+   robot_grid_status_t expected = { HEADING_EAST, {0, 0} };
    robot_grid_status_t actual = robot_init();
 
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_south;
+   expected.bearing = HEADING_SOUTH;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_west;
+   expected.bearing = HEADING_WEST;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_north;
+   expected.bearing = HEADING_NORTH;
    robot_turn_right(&actual);
    confirm_position(&expected, &actual);
 }
@@ -65,21 +73,21 @@ void test_turn_right(void)
 void test_turn_left(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_west, {0, 0} };
+   robot_grid_status_t expected = { HEADING_WEST, {0, 0} };
    robot_grid_status_t actual = robot_init();
 
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_south;
+   expected.bearing = HEADING_SOUTH;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_east;
+   expected.bearing = HEADING_EAST;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 
-   expected.bearing = heading_north;
+   expected.bearing = HEADING_NORTH;
    robot_turn_left(&actual);
    confirm_position(&expected, &actual);
 }
@@ -87,7 +95,7 @@ void test_turn_left(void)
 void test_advance_positive_north(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_north, {0, 1} };
+   robot_grid_status_t expected = { HEADING_NORTH, {0, 1} };
    robot_grid_status_t actual = robot_init();
 
    robot_advance(&actual);
@@ -97,8 +105,8 @@ void test_advance_positive_north(void)
 void test_advance_positive_east(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_east, {1, 0} };
-   robot_grid_status_t actual = robot_init_with_position(heading_east, 0, 0);
+   robot_grid_status_t expected = { HEADING_EAST, {1, 0} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_EAST, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -107,8 +115,8 @@ void test_advance_positive_east(void)
 void test_advance_negative_south(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_south, {0, -1} };
-   robot_grid_status_t actual = robot_init_with_position(heading_south, 0, 0);
+   robot_grid_status_t expected = { HEADING_SOUTH, {0, -1} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_SOUTH, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -117,8 +125,8 @@ void test_advance_negative_south(void)
 void test_advance_negative_west(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_west, {-1, 0} };
-   robot_grid_status_t actual = robot_init_with_position(heading_west, 0, 0);
+   robot_grid_status_t expected = { HEADING_WEST, {-1, 0} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_WEST, 0, 0);
 
    robot_advance(&actual);
    confirm_position(&expected, &actual);
@@ -127,7 +135,7 @@ void test_advance_negative_west(void)
 void test_simulate_move_west_and_north(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_west, {-4, 1} };
+   robot_grid_status_t expected = { HEADING_WEST, {-4, 1} };
    robot_grid_status_t actual = robot_init();
 
    robot_simulator(&actual, "LAAARALA");
@@ -137,8 +145,8 @@ void test_simulate_move_west_and_north(void)
 void test_simulate_move_west_and_south(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_south, {-3, -8} };
-   robot_grid_status_t actual = robot_init_with_position(heading_east, 2, -7);
+   robot_grid_status_t expected = { HEADING_SOUTH, {-3, -8} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_EAST, 2, -7);
 
    robot_simulator(&actual, "RRAAAAALA");
    confirm_position(&expected, &actual);
@@ -147,8 +155,8 @@ void test_simulate_move_west_and_south(void)
 void test_simulate_move_east_and_north(void)
 {
    TEST_IGNORE();
-   robot_grid_status_t expected = { heading_north, {11, 5} };
-   robot_grid_status_t actual = robot_init_with_position(heading_south, 8, 4);
+   robot_grid_status_t expected = { HEADING_NORTH, {11, 5} };
+   robot_grid_status_t actual = robot_init_with_position(HEADING_SOUTH, 8, 4);
 
    robot_simulator(&actual, "LAAARRRALLLL");
    confirm_position(&expected, &actual);

data/tracks/c/exercises/roman-numerals/test/test_roman_numerals.c

@@ -2,6 +2,14 @@
 #include "../src/roman_numerals.h"
 #include <stdlib.h>
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 static void test_conversion(int number, char *expected)
 {
    char *result = to_roman_numeral(number);

data/tracks/c/exercises/scrabble-score/test/test_scrabble_score.c

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/scrabble_score.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_lowercase_letter(void)
 {
    TEST_ASSERT_EQUAL(1, score("a"));

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

@@ -2,6 +2,14 @@
 #include "vendor/unity.h"
 #include "../src/series.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 // helper routines to validate test results
 static void test_solution(series_results_t * expected_solution,
                           series_results_t * actual_solution)

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

@@ -4,6 +4,14 @@
 
 static primes_array_t result_array;
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_no_primes_under_two(void)
 {
    const unsigned int limit = 1;

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

@@ -2,14 +2,14 @@
 #define SPACE_AGE_H
 
 typedef enum planet {
-   mercury,
-   venus,
-   earth,
-   mars,
-   jupiter,
-   saturn,
-   uranus,
-   neptune,
+   MERCURY,
+   VENUS,
+   EARTH,
+   MARS,
+   JUPITER,
+   SATURN,
+   URANUS,
+   NEPTUNE,
 } planet_t;
 
 float convert_planet_age(planet_t planet, const long input);

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

@@ -1,51 +1,59 @@
 #include "vendor/unity.h"
 #include "../src/space_age.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_convert_earth_year(void)
 {
-   TEST_ASSERT_FLOAT_WITHIN(1, 31.69, convert_planet_age(earth, 1000000000));
+   TEST_ASSERT_FLOAT_WITHIN(1, 31.69, convert_planet_age(EARTH, 1000000000));
 }
 
 void test_convert_mercury_year(void)
 {
    TEST_IGNORE();               // delete this line to run test
-   TEST_ASSERT_FLOAT_WITHIN(3, 280.88, convert_planet_age(mercury, 2134835688));
+   TEST_ASSERT_FLOAT_WITHIN(3, 280.88, convert_planet_age(MERCURY, 2134835688));
 }
 
 void test_convert_venus_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(1, 9.78, convert_planet_age(venus, 189839836));
+   TEST_ASSERT_FLOAT_WITHIN(1, 9.78, convert_planet_age(VENUS, 189839836));
 }
 
 void test_convert_mars_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(1, 39.25, convert_planet_age(mars, 2329871239));
+   TEST_ASSERT_FLOAT_WITHIN(1, 39.25, convert_planet_age(MARS, 2329871239));
 }
 
 void test_convert_jupiter_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(0.1, 2.41, convert_planet_age(jupiter, 901876382));
+   TEST_ASSERT_FLOAT_WITHIN(0.1, 2.41, convert_planet_age(JUPITER, 901876382));
 }
 
 void test_convert_saturn_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(0.1, 3.23, convert_planet_age(saturn, 3000000000));
+   TEST_ASSERT_FLOAT_WITHIN(0.1, 3.23, convert_planet_age(SATURN, 3000000000));
 }
 
 void test_convert_uranus_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(0.1, 1.21, convert_planet_age(uranus, 3210123456));
+   TEST_ASSERT_FLOAT_WITHIN(0.1, 1.21, convert_planet_age(URANUS, 3210123456));
 }
 
 void test_convert_neptune_year(void)
 {
    TEST_IGNORE();
-   TEST_ASSERT_FLOAT_WITHIN(0.1, 1.58, convert_planet_age(neptune, 8210123456));
+   TEST_ASSERT_FLOAT_WITHIN(0.1, 1.58, convert_planet_age(NEPTUNE, 8210123456));
 }
 
 int main(void)

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

@@ -3,6 +3,14 @@
 
 #define NUM_OF_ELEMENTS(a)    (sizeof(a) / sizeof(a[0]))
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_sum_of_multiples_of_3_and_5_up_to_1(void)
 {
    const unsigned int multiples[] = { 3, 5 };

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

@@ -1,6 +1,14 @@
 #include "vendor/unity.h"
 #include "../src/triangle.h"
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 void test_equilateral_is_true_if_all_sides_are_equal(void)
 {
    triangle_t sides = { 2, 2, 2 };

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

@@ -6,6 +6,14 @@
 
 word_count_word_t actual_solution[MAX_WORDS];
 
+void setUp(void)
+{
+}
+
+void tearDown(void)
+{
+}
+
 static void test_solution(word_count_word_t * expected_solution,
                           int expected_word_count,
                           word_count_word_t * actual_solution,

data/tracks/cfml/config.json

@@ -166,6 +166,14 @@
             "uuid":"4594B907-8080-4A23-AD06-BE85FC28D088",
             "topics":[
                 
+            ]
+        },
+        {
+            "difficulty":1,
+            "slug":"anagram",
+            "uuid":"339BACAD-F08F-48EE-8DE9-234D4399B49B",
+            "topics":[
+                
             ]
         }
     ],

data/tracks/cfml/exercises/anagram/Anagram.cfc

@@ -0,0 +1,13 @@
+/**
+* Your implmentation of the Anagram exercise
+*/
+component {
+	
+	/**
+	* @returns 
+	*/
+	function anagrams( string subject, array candidates ) {
+		// Implement me here
+	}
+	
+}

data/tracks/cfml/exercises/anagram/AnagramTest.cfc

@@ -0,0 +1,79 @@
+component extends="testbox.system.BaseSpec" {
+
+	function beforeAll(){
+	  SUT = createObject( 'Anagram' );
+	}
+
+	function run(){
+	
+		describe( "My Anagram class", function(){			
+
+			it( 'no matches', function(){
+				expect( SUT.anagrams( subject='diaper', candidates=["hello", "world", "zombies", "pants"] ) ).toBe( [] );
+			});
+
+			it( 'detects simple anagram', function(){
+				expect( SUT.anagrams( subject='ant', candidates=["tan", "stand", "at"] ) ).toBe( ["tan"] );
+			});
+
+			it( 'does not detect false positives', function(){
+				expect( SUT.anagrams( subject='galea', candidates=["eagle"] ) ).toBe( [] );
+			});
+
+			it( 'detects two anagrams', function(){
+				expect( SUT.anagrams( subject='master', candidates=["stream", "pigeon", "maters"] ) ).toBe( ["stream","maters"] );
+			});
+
+			it( 'does not detect anagram subsets', function(){
+				expect( SUT.anagrams( subject='good', candidates=["dog", "goody"] ) ).toBe( [] );
+			});
+
+			it( 'detects anagram', function(){
+				expect( SUT.anagrams( subject='listen', candidates=["enlists", "google", "inlets", "banana"] ) ).toBe( ["inlets"] );
+			});
+
+			it( 'detects three anagrams', function(){
+				expect( SUT.anagrams( subject='allergy', candidates=["gallery", "ballerina", "regally", "clergy", "largely", "leading"] ) ).toBe( ["gallery","regally","largely"] );
+			});
+
+			it( 'does not detect identical words', function(){
+				expect( SUT.anagrams( subject='corn', candidates=["corn", "dark", "Corn", "rank", "CORN", "cron", "park"] ) ).toBe( ["cron"] );
+			});
+
+			it( 'does not detect non-anagrams with identical checksum', function(){
+				expect( SUT.anagrams( subject='mass', candidates=["last"] ) ).toBe( [] );
+			});
+
+			it( 'detects anagrams case-insensitively', function(){
+				expect( SUT.anagrams( subject='Orchestra', candidates=["cashregister", "Carthorse", "radishes"] ) ).toBe( ["Carthorse"] );
+			});
+
+			it( 'detects anagrams using case-insensitive subject', function(){
+				expect( SUT.anagrams( subject='Orchestra', candidates=["cashregister", "carthorse", "radishes"] ) ).toBe( ["carthorse"] );
+			});
+
+			it( 'detects anagrams using case-insensitive possible matches', function(){
+				expect( SUT.anagrams( subject='orchestra', candidates=["cashregister", "Carthorse", "radishes"] ) ).toBe( ["Carthorse"] );
+			});
+
+			it( 'does not detect a word as its own anagram', function(){
+				expect( SUT.anagrams( subject='banana', candidates=["Banana"] ) ).toBe( [] );
+			});
+
+			it( 'does not detect a anagram if the original word is repeated', function(){
+				expect( SUT.anagrams( subject='go', candidates=["go Go GO"] ) ).toBe( [] );
+			});
+
+			it( 'anagrams must use all letters exactly once', function(){
+				expect( SUT.anagrams( subject='tapper', candidates=["patter"] ) ).toBe( [] );
+			});
+
+			it( 'capital word is not own anagram', function(){
+				expect( SUT.anagrams( subject='BANANA', candidates=["Banana"] ) ).toBe( [] );
+			});
+
+		});
+		
+	}
+ 
+}