trackler 2.0.0.1 → 2.0.0.2

data/tracks/php/exercises/pig-latin/example.php

@@ -1,36 +1,32 @@
 <?php
+/**
+ * Translates a string into Pig Latin
+ *
+ * @param  string $str
+ * @return string
+ */
+function translate($str)
+{
+    $words = explode(" ", $str);
+    $translatedWords = array_map('translateWord', $words);
+    return implode(' ', $translatedWords);
+}
 
-class PigLatin
+/**
+ * Translates a single word
+ *
+ * @param  string $str
+ * @return string
+ */
+function translateWord($str)
 {
-    /**
-     * Translates a string into Pig Latin
-     *
-     * @param  string $str
-     * @return string
-     */
-    public static function translate($str)
-    {
-        $words = explode(" ", $str);
-        $translatedWords = array_map(["self", 'translateWord'], $words);
-        return implode(' ', $translatedWords);
+    if (preg_match('/^s?qu|thr?|s?ch/', $str, $match)) {
+        return sprintf("%s%say", substr($str, strlen($match[0])), $match[0]);
     }
 
-    /**
-     * Translates a single word
-     *
-     * @param  string $str
-     * @return string
-     */
-    private static function translateWord($str)
-    {
-        if (preg_match('/^s?qu|thr?|s?ch/', $str, $match)) {
-            return sprintf("%s%say", substr($str, strlen($match[0])), $match[0]);
-        }
-
-        if (preg_match('/^[aeiou]|yt|xr/', $str)) {
-            return sprintf("%say", $str);
-        }
-
-        return sprintf("%s%say", substr($str, 1), $str[0]);
+    if (preg_match('/^[aeiou]|yt|xr/', $str)) {
+        return sprintf("%say", $str);
     }
+
+    return sprintf("%s%say", substr($str, 1), $str[0]);
 }

data/tracks/php/exercises/pig-latin/pig-latin_test.php

@@ -5,63 +5,70 @@ class PigLatinTest extends PHPUnit_Framework_TestCase
 {
     public function testWordBeginningWithP()
     {
-        $this->assertEquals("igpay", PigLatin::translate("pig"));
+        $this->assertEquals("igpay", translate("pig"));
     }
 
     public function testWordBeginningWithK()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("oalakay", PigLatin::translate("koala"));
+        $this->assertEquals("oalakay", translate("koala"));
     }
 
     public function testWordBeginningWithY()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("ellowyay", PigLatin::translate("yellow"));
+        $this->assertEquals("ellowyay", translate("yellow"));
     }
 
     public function testWordBeginningWithX()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("enonxay", PigLatin::translate("xenon"));
+        $this->assertEquals("enonxay", translate("xenon"));
     }
 
     public function testWordBeginningWithA()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("appleay", PigLatin::translate("apple"));
+        $this->assertEquals("appleay", translate("apple"));
     }
 
     public function testWordBeginningWithE()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("earay", PigLatin::translate("ear"));
+        $this->assertEquals("earay", translate("ear"));
     }
 
     public function testWordBeginningWithI()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("iglooay", PigLatin::translate("igloo"));
+        $this->assertEquals("iglooay", translate("igloo"));
     }
 
     public function testWordBeginningWithO()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("objectay", PigLatin::translate("object"));
+        $this->assertEquals("objectay", translate("object"));
     }
 
     public function testWordBeginningWithU()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("underay", PigLatin::translate("under"));
+        $this->assertEquals("underay", translate("under"));
+    }
+
+    public function testWordBeginningVowelFollowedByQu()
+    {
+        $this->markTestSkipped();
+
+        $this->assertEquals("equalay", translate("equal"));
     }
 
 
@@ -69,7 +76,7 @@ class PigLatinTest extends PHPUnit_Framework_TestCase
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("atqay", PigLatin::translate("qat"));
+        $this->assertEquals("atqay", translate("qat"));
     }
 
 
@@ -77,62 +84,62 @@ class PigLatinTest extends PHPUnit_Framework_TestCase
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("airchay", PigLatin::translate("chair"));
+        $this->assertEquals("airchay", translate("chair"));
     }
 
     public function testWordBeginningWithQu()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("eenquay", PigLatin::translate("queen"));
+        $this->assertEquals("eenquay", translate("queen"));
     }
 
     public function testWordBeginningWithQuAndAPrecedingConsonant()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("aresquay", PigLatin::translate("square"));
+        $this->assertEquals("aresquay", translate("square"));
     }
 
     public function testWordBeginningWithTh()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("erapythay", PigLatin::translate("therapy"));
+        $this->assertEquals("erapythay", translate("therapy"));
     }
 
     public function testWordBeginningWithThr()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("ushthray", PigLatin::translate("thrush"));
+        $this->assertEquals("ushthray", translate("thrush"));
     }
 
     public function testWordBeginningWithSch()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("oolschay", PigLatin::translate("school"));
+        $this->assertEquals("oolschay", translate("school"));
     }
 
     public function testWordBeginningWithYt()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("yttriaay", PigLatin::translate("yttria"));
+        $this->assertEquals("yttriaay", translate("yttria"));
     }
 
     public function testWordBeginningWithXr()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("xrayay", PigLatin::translate("xray"));
+        $this->assertEquals("xrayay", translate("xray"));
     }
 
     public function testAWholePhrase()
     {
         $this->markTestSkipped();
 
-        $this->assertEquals("ickquay astfay unray", PigLatin::translate("quick fast run"));
+        $this->assertEquals("ickquay astfay unray", translate("quick fast run"));
     }
 }

data/tracks/php/exercises/space-age/example.php

@@ -0,0 +1,65 @@
+<?php
+
+class SpaceAge
+{
+    public $seconds;
+
+    const EARTH_YEAR_IN_SECONDS = 31557600;
+    const MERCURY_YEAR_IN_EY    = 0.2408467;
+    const VENUS_YEAR_IN_EY      = 0.61519726;
+    const MARS_YEAR_IN_EY       = 1.8808158;
+    const JUPITER_YEAR_IN_EY    = 11.862615;
+    const SATURN_YEAR_IN_EY     = 29.447498;
+    const URANUS_YEAR_IN_EY     = 84.016846;
+    const NEPTUNE_YEAR_IN_EY    = 164.79132;
+
+    public function __construct($seconds)
+    {
+        $this->seconds = $seconds;
+    }
+    
+    public function seconds()
+    {
+        return $this->seconds;
+    }
+
+    public function earth()
+    {
+        return $this->seconds / self::EARTH_YEAR_IN_SECONDS;
+    }
+
+    public function mercury()
+    {
+        return $this->earth() / self::MERCURY_YEAR_IN_EY;
+    }
+
+    public function venus()
+    {
+        return $this->earth() / self::VENUS_YEAR_IN_EY;
+    }
+
+    public function mars()
+    {
+        return $this->earth() / self::MARS_YEAR_IN_EY;
+    }
+
+    public function jupiter()
+    {
+        return $this->earth() / self::JUPITER_YEAR_IN_EY;
+    }
+
+    public function saturn()
+    {
+        return $this->earth() / self::SATURN_YEAR_IN_EY;
+    }
+
+    public function uranus()
+    {
+        return $this->earth() / self::URANUS_YEAR_IN_EY;
+    }
+
+    public function neptune()
+    {
+        return $this->earth() / self::NEPTUNE_YEAR_IN_EY;
+    }
+}

data/tracks/php/exercises/space-age/space-age_test.php

@@ -0,0 +1,70 @@
+<?php
+
+require "space-age.php";
+
+class SpaceAgeTester extends PHPUnit_Framework_TestCase
+{
+    const DELTA = 0.01;
+
+    public function testAgeInSeconds()
+    {
+        $age = new SpaceAge(1000000);
+        $this->assertEquals(1000000, $age->seconds());
+    }
+
+    public function testAgeOnEarth()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(1000000000);
+        $this->assertEquals(31.69, $age->earth(), '', self::DELTA);
+    }
+
+    public function testAgeOnMercury()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(2134835688);
+        $this->assertEquals(280.88, $age->mercury(), '', self::DELTA);
+    }
+
+    public function testAgeOnVenus()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(189839836);
+        $this->assertEquals(9.78, $age->venus(), '', self::DELTA);
+    }
+
+    public function testAgeOnMars()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(2329871239);
+        $this->assertEquals(39.25, $age->mars(), '', self::DELTA);
+    }
+
+    public function testAgeOnJupiter()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(901876382);
+        $this->assertEquals(2.41, $age->jupiter(), '', self::DELTA);
+    }
+
+    public function testAgeOnSaturn()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(3000000000);
+        $this->assertEquals(3.23, $age->saturn(), '', self::DELTA);
+    }
+
+    public function testAgeOnUranus()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(3210123456);
+        $this->assertEquals(1.21, $age->uranus(), '', self::DELTA);
+    }
+
+    public function testAgeOnNeptune()
+    {
+        $this->markTestSkipped();
+        $age = new SpaceAge(8210123456);
+        $this->assertEquals(1.58, $age->neptune(), '', self::DELTA);
+    }
+}

data/tracks/php/exercises/triangle/example.php

@@ -0,0 +1,43 @@
+<?php
+
+class Triangle
+{
+    protected $sideA;
+    protected $sideB;
+    protected $sideC;
+
+    public function __construct($sideA, $sideB, $sideC)
+    {
+        $this->sideA = $sideA;
+        $this->sideB = $sideB;
+        $this->sideC = $sideC;
+    }
+    
+    public function kind()
+    {
+        if (0 == ($this->sideA + $this->sideB + $this->sideC)) {
+            throw new \Exception("These sides have no values.");
+        }
+
+        $sides = [$this->sideA, $this->sideB, $this->sideC];
+        sort($sides);
+        if ($sides[2] >= $sides[0] + $sides[1]) {
+            throw new \Exception("This violates the triangle inequality");
+        }
+
+        if ($this->sideA == $this->sideB &&
+            $this->sideA == $this->sideC
+        ) {
+            return 'equilateral';
+        }
+
+        if ($this->sideB == $this->sideC ||
+            $this->sideA == $this->sideC ||
+            $this->sideA == $this->sideB
+        ) {
+            return 'isosceles';
+        }
+
+        return 'scalene';
+    }
+}

data/tracks/php/exercises/triangle/triangle_test.php

@@ -0,0 +1,140 @@
+<?php
+
+require "triangle.php";
+
+class TriangleTest extends \PHPUnit_Framework_TestCase
+{
+    public function testEquilateralTrianglesHaveEqualSides()
+    {
+        $this->assertEquals(
+            'equilateral',
+            (new Triangle(2, 2, 2))->kind()
+        );
+    }
+
+    public function testLargerEquilateralTrianglesHaveEqualSides()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'equilateral',
+            (new Triangle(10, 10, 10))->kind()
+        );
+    }
+
+    public function testIsoscelesTriangleWhenLastTwoSidesAreEqual()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'isosceles',
+            (new Triangle(3, 4, 4))->kind()
+        );
+    }
+
+    public function testIsoscelesTriangleWhenFirstAndLastSidesAreEqual()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'isosceles',
+            (new Triangle(4, 3, 4))->kind()
+        );
+    }
+
+    public function testIsoscelesTriangleWhenFirstTwoSidesAreEqual()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'isosceles',
+            (new Triangle(4, 4, 3))->kind()
+        );
+    }
+
+    public function testIsoscelesTrianglesWithUnequalSideLargerThanEqualSides()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'isosceles',
+            (new Triangle(4, 4, 7))->kind()
+        );
+    }
+
+    public function testScaleneTrianglesHaveNoEqualSides()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'scalene',
+            (new Triangle(3, 4, 5))->kind()
+        );
+    }
+
+    public function test2aEqualsBPlusCLooksLikeEquilateralButIsNot()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'scalene',
+            (new Triangle(5, 4, 6))->kind()
+        );
+    }
+
+    public function testScaleneTrianglesHaveNoEqualSidesAtLargerScale()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'scalene',
+            (new Triangle(10, 11, 12))->kind()
+        );
+    }
+
+    public function testScaleneTrianglesHaveNoEqualSidesInDescendingOrder()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'scalene',
+            (new Triangle(5, 4, 2))->kind()
+        );
+    }
+
+    public function testVerySmallTrianglesAreLegal()
+    {
+        $this->markTestSkipped();
+        $this->assertEquals(
+            'scalene',
+            (new Triangle(0.4, 0.6, 0.3))->kind()
+        );
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testTrianglesWithNoSizeAreIllegal()
+    {
+        $this->markTestSkipped();
+        (new Triangle(0, 0, 0))->kind();
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testTrianglesViolatingTriangleInequalityAreIllegal()
+    {
+        $this->markTestSkipped();
+        (new Triangle(1, 1, 3))->kind();
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testTrianglesViolatingTriangleInequalityAreIllegal2()
+    {
+        $this->markTestSkipped();
+        (new Triangle(7, 3, 2))->kind();
+    }
+
+    /**
+     * @expectedException \Exception
+     */
+    public function testTrianglesViolatingTriangleInequalityAreIllegal3()
+    {
+        $this->markTestSkipped();
+        (new Triangle(1, 3, 1))->kind();
+    }
+}

data/tracks/pony/exercises/anagram/example.pony

@@ -1,4 +1,4 @@
-use "PonyTest"
+use "ponytest"
 
 class Anagram
 
@@ -9,7 +9,7 @@ class Anagram
 
     for (index, value) in phrase.pairs() do
       let value_array: Array[U8] = _to_array_and_order(value.lower())
-      
+
       if value.size() != word.size() then continue end
       if value.lower() == word.lower() then continue end
       if _check_array_eq(word_array, value_array) then
@@ -18,9 +18,9 @@ class Anagram
     end
 
     anagrams
-        
+
   fun _to_array_and_order(word: String): Array[U8] ? =>
-    // As of right now the String.split() function doesn't appear to work 
+    // As of right now the String.split() function doesn't appear to work
     // on no delimiter, i.e. "abcd".split("") to ["a", "b", "c", "d"]
     // So I pull of the bytes
 
@@ -31,7 +31,7 @@ class Anagram
       word_array.push(value)
     end
 
-    
+
     for (index, value) in word_array.pairs() do
       var inserted = false
       if (index == 0) then sorted_array.push(value) end
@@ -60,7 +60,7 @@ class Anagram
     if expect.size() != actual.size() then
       ok = false
     else
-      var i: U64 = 0
+      var i: USize = 0
       while i < expect.size() do
         if expect(i) != actual(i) then
           ok = false

data/tracks/pony/exercises/anagram/test.pony

@@ -10,14 +10,14 @@ actor Main is TestList
   fun tag tests(test: PonyTest) =>
     test(_AnagramTest)
 
-class _AnagramTest iso is UnitTest
+class iso _AnagramTest is UnitTest
   """
-  Test Anagram package 
+  Test Anagram package
   """
 
   fun name(): String => "anagram/Anagram"
 
-  fun apply(h: TestHelper): TestResult ? =>
+  fun apply(h: TestHelper): None ? =>
     let anagrams =  ["banana", "bob", "sent", "sale", "ales"]
     let emptyArray: Array[String] = Array[String]
 
@@ -33,4 +33,3 @@ class _AnagramTest iso is UnitTest
     h.assert_array_eq[String](["sent"],Anagram("nETs", anagrams))
     // Anagram should return multiple anagrams
     h.assert_array_eq[String](["sale", "ales"], Anagram("seal", anagrams))
-    true 

data/tracks/pony/exercises/bob/test.pony

@@ -13,60 +13,60 @@ actor Main is TestList
     test(_BobSilentTest)
     test(_BobDefaultTest)
 
-class _BobShoutTest iso is UnitTest
+class iso _BobShoutTest is UnitTest
   """
   Test matching when Bob is shouted at
   """
   fun name(): String => "bob/Bob"
 
-  fun apply(h: TestHelper): TestResult ? =>
+  fun apply(h: TestHelper): None ? =>
     let shout_resp: String = "Whoa, chill out!"
 
-    h.expect_eq[String](shout_resp, Bob("WATCH OUT!"))
-    h.expect_eq[String](shout_resp, Bob("WHAT THE HELL WERE YOU THINKING?"))
-    h.expect_eq[String](shout_resp, Bob("1, 2, 3 GO!"))
-    h.expect_eq[String](shout_resp, Bob("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"))
+    h.assert_eq[String](shout_resp, Bob("WATCH OUT!"))
+    h.assert_eq[String](shout_resp, Bob("WHAT THE HELL WERE YOU THINKING?"))
+    h.assert_eq[String](shout_resp, Bob("1, 2, 3 GO!"))
+    h.assert_eq[String](shout_resp, Bob("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"))
 
-class _BobQuestionTest iso is UnitTest
+class iso _BobQuestionTest is UnitTest
   """
   Test matching when Bob is questioned
   """
 
   fun name(): String => "bob/Bob"
 
-  fun apply(h: TestHelper): TestResult ? =>
+  fun apply(h: TestHelper): None ? =>
     let ques_resp: String = "Sure."
 
-    h.expect_eq[String](ques_resp, Bob("Does this cryogenic chamber make me look fat?"))
-    h.expect_eq[String](ques_resp, Bob("You are, what, like 15?"))
-    h.expect_eq[String](ques_resp, Bob("4?"))
-    h.expect_eq[String](ques_resp, Bob("Wait! Hang on. Are you going to be OK?"))
+    h.assert_eq[String](ques_resp, Bob("Does this cryogenic chamber make me look fat?"))
+    h.assert_eq[String](ques_resp, Bob("You are, what, like 15?"))
+    h.assert_eq[String](ques_resp, Bob("4?"))
+    h.assert_eq[String](ques_resp, Bob("Wait! Hang on. Are you going to be OK?"))
 
-class _BobSilentTest iso is UnitTest
+class iso _BobSilentTest is UnitTest
   """
   Test matching when Bob faces silence
   """
 
   fun name(): String => "bob/Bob"
 
-  fun apply(h: TestHelper): TestResult ? =>
+  fun apply(h: TestHelper): None ? =>
     let silent_resp: String = "Fine. Be that way!"
 
-    h.expect_eq[String](silent_resp, Bob(""))
-    h.expect_eq[String](silent_resp, Bob("   "))
+    h.assert_eq[String](silent_resp, Bob(""))
+    h.assert_eq[String](silent_resp, Bob("   "))
 
-class _BobDefaultTest iso is UnitTest
+class iso _BobDefaultTest is UnitTest
   """
   Test matching when Bob is defaulting
   """
 
   fun name(): String => "bob/Bob"
 
-  fun apply(h: TestHelper): TestResult ? =>
+  fun apply(h: TestHelper): None ? =>
     let default_resp: String = "Whatever."
 
-    h.expect_eq[String](default_resp, Bob("Tom-ay-to, tom-aaaah-to."))
-    h.expect_eq[String](default_resp, Bob("Let's go make out behind the gym!"))
-    h.expect_eq[String](default_resp, Bob("It's OK if you don't want to go to the DMV."))
-    h.expect_eq[String](default_resp, Bob("1, 2, 3"))
-    h.expect_eq[String](default_resp, Bob("Ending with ? means a question."))
+    h.assert_eq[String](default_resp, Bob("Tom-ay-to, tom-aaaah-to."))
+    h.assert_eq[String](default_resp, Bob("Let's go make out behind the gym!"))
+    h.assert_eq[String](default_resp, Bob("It's OK if you don't want to go to the DMV."))
+    h.assert_eq[String](default_resp, Bob("1, 2, 3"))
+    h.assert_eq[String](default_resp, Bob("Ending with ? means a question."))