trackler 2.0.8.24 → 2.0.8.26

data/tracks/purescript/exercises/meetup/test/Main.purs

@@ -0,0 +1,395 @@
+module Test.Main where
+
+import Prelude
+import Test.Unit.Assert as Assert
+import Control.Monad.Eff (Eff)
+import Data.Date (Weekday(..), canonicalDate)
+import Data.Enum (toEnum)
+import Data.Maybe (Maybe(..))
+import Meetup (Week(..), meetup)
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "Meetup.meetup" do
+
+    test "monteenth of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Teenth <@> Monday)
+
+    test "monteenth of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Teenth <@> Monday)
+
+    test "monteenth of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Teenth <@> Monday)
+
+    test "tuesteenth of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Teenth <@> Tuesday)
+
+    test "tuesteenth of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Teenth <@> Tuesday)
+
+    test "tuesteenth of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Teenth <@> Tuesday)
+
+    test "wednesteenth of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> Teenth <@> Wednesday)
+
+    test "wednesteenth of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Teenth <@> Wednesday)
+
+    test "wednesteenth of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Teenth <@> Wednesday)
+
+    test "thursteenth of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Teenth <@> Thursday)
+
+    test "thursteenth of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Teenth <@> Thursday)
+
+    test "thursteenth of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Teenth <@> Thursday)
+
+    test "friteenth of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Teenth <@> Friday)
+
+    test "friteenth of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Teenth <@> Friday)
+
+    test "friteenth of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Teenth <@> Friday)
+
+    test "saturteenth of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Teenth <@> Saturday)
+
+    test "saturteenth of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Teenth <@> Saturday)
+
+    test "saturteenth of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Teenth <@> Saturday)
+
+    test "sunteenth of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Teenth <@> Sunday)
+
+    test "sunteenth of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Teenth <@> Sunday)
+
+    test "sunteenth of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Teenth <@> Sunday)
+
+    test "first Monday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 4) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> First <@> Monday)
+
+    test "first Monday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 1) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> First <@> Monday)
+
+    test "first Tuesday of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 7) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> First <@> Tuesday)
+
+    test "first Tuesday of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 4) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> First <@> Tuesday)
+
+    test "first Wednesday of July 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 7 <*> toEnum 3) 
+                   (meetup <$> toEnum 2013 <*> toEnum 7 <@> First <@> Wednesday)
+
+    test "first Wednesday of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 7) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> First <@> Wednesday)
+
+    test "first Thursday of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 5) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> First <@> Thursday)
+
+    test "first Thursday of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 3) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> First <@> Thursday)
+
+    test "first Friday of November 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 11 <*> toEnum 1) 
+                   (meetup <$> toEnum 2013 <*> toEnum 11 <@> First <@> Friday)
+
+    test "first Friday of December 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 12 <*> toEnum 6) 
+                   (meetup <$> toEnum 2013 <*> toEnum 12 <@> First <@> Friday)
+
+    test "first Saturday of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 5) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> First <@> Saturday)
+
+    test "first Saturday of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 2) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> First <@> Saturday)
+
+    test "first Sunday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 3) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> First <@> Sunday)
+
+    test "first Sunday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 7) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> First <@> Sunday)
+
+    test "second Monday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 11) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Second <@> Monday)
+
+    test "second Monday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 8) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Second <@> Monday)
+
+    test "second Tuesday of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 14) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Second <@> Tuesday)
+
+    test "second Tuesday of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 11) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Second <@> Tuesday)
+
+    test "second Wednesday of July 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 7 <*> toEnum 10) 
+                   (meetup <$> toEnum 2013 <*> toEnum 7 <@> Second <@> Wednesday)
+
+    test "second Wednesday of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 14) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Second <@> Wednesday)
+
+    test "second Thursday of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 12) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Second <@> Thursday)
+
+    test "second Thursday of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 10) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Second <@> Thursday)
+
+    test "second Friday of November 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 11 <*> toEnum 8) 
+                   (meetup <$> toEnum 2013 <*> toEnum 11 <@> Second <@> Friday)
+
+    test "second Friday of December 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 12 <*> toEnum 13) 
+                   (meetup <$> toEnum 2013 <*> toEnum 12 <@> Second <@> Friday)
+
+    test "second Saturday of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 12) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> Second <@> Saturday)
+
+    test "second Saturday of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 9) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Second <@> Saturday)
+
+    test "second Sunday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 10) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Second <@> Sunday)
+
+    test "second Sunday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 14) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Second <@> Sunday)
+
+    test "third Monday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 18) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Third <@> Monday)
+
+    test "third Monday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 15) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Third <@> Monday)
+
+    test "third Tuesday of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 21) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Third <@> Tuesday)
+
+    test "third Tuesday of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 18) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Third <@> Tuesday)
+
+    test "third Wednesday of July 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 7 <*> toEnum 17) 
+                   (meetup <$> toEnum 2013 <*> toEnum 7 <@> Third <@> Wednesday)
+
+    test "third Wednesday of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 21) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Third <@> Wednesday)
+
+    test "third Thursday of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Third <@> Thursday)
+
+    test "third Thursday of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 17) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Third <@> Thursday)
+
+    test "third Friday of November 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 11 <*> toEnum 15) 
+                   (meetup <$> toEnum 2013 <*> toEnum 11 <@> Third <@> Friday)
+
+    test "third Friday of December 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 12 <*> toEnum 20) 
+                   (meetup <$> toEnum 2013 <*> toEnum 12 <@> Third <@> Friday)
+
+    test "third Saturday of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 19) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> Third <@> Saturday)
+
+    test "third Saturday of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 16) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Third <@> Saturday)
+
+    test "third Sunday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 17) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Third <@> Sunday)
+
+    test "third Sunday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 21) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Third <@> Sunday)
+
+    test "fourth Monday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 25) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Fourth <@> Monday)
+
+    test "fourth Monday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 22) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Fourth <@> Monday)
+
+    test "fourth Tuesday of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Fourth <@> Tuesday)
+
+    test "fourth Tuesday of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 25) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Fourth <@> Tuesday)
+
+    test "fourth Wednesday of July 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 7 <*> toEnum 24) 
+                   (meetup <$> toEnum 2013 <*> toEnum 7 <@> Fourth <@> Wednesday)
+
+    test "fourth Wednesday of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Fourth <@> Wednesday)
+
+    test "fourth Thursday of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 26) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Fourth <@> Thursday)
+
+    test "fourth Thursday of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 24) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Fourth <@> Thursday)
+
+    test "fourth Friday of November 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 11 <*> toEnum 22) 
+                   (meetup <$> toEnum 2013 <*> toEnum 11 <@> Fourth <@> Friday)
+
+    test "fourth Friday of December 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 12 <*> toEnum 27) 
+                   (meetup <$> toEnum 2013 <*> toEnum 12 <@> Fourth <@> Friday)
+
+    test "fourth Saturday of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 26) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> Fourth <@> Saturday)
+
+    test "fourth Saturday of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 23) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Fourth <@> Saturday)
+
+    test "fourth Sunday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 24) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Fourth <@> Sunday)
+
+    test "fourth Sunday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Fourth <@> Sunday)
+
+    test "last Monday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 25) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Last <@> Monday)
+
+    test "last Monday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 29) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Last <@> Monday)
+
+    test "last Tuesday of May 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 5 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 5 <@> Last <@> Tuesday)
+
+    test "last Tuesday of June 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 6 <*> toEnum 25) 
+                   (meetup <$> toEnum 2013 <*> toEnum 6 <@> Last <@> Tuesday)
+
+    test "last Wednesday of July 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 7 <*> toEnum 31) 
+                   (meetup <$> toEnum 2013 <*> toEnum 7 <@> Last <@> Wednesday)
+
+    test "last Wednesday of August 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 8 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 8 <@> Last <@> Wednesday)
+
+    test "last Thursday of September 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 9 <*> toEnum 26) 
+                   (meetup <$> toEnum 2013 <*> toEnum 9 <@> Last <@> Thursday)
+
+    test "last Thursday of October 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 10 <*> toEnum 31) 
+                   (meetup <$> toEnum 2013 <*> toEnum 10 <@> Last <@> Thursday)
+
+    test "last Friday of November 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 11 <*> toEnum 29) 
+                   (meetup <$> toEnum 2013 <*> toEnum 11 <@> Last <@> Friday)
+
+    test "last Friday of December 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 12 <*> toEnum 27) 
+                   (meetup <$> toEnum 2013 <*> toEnum 12 <@> Last <@> Friday)
+
+    test "last Saturday of January 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 1 <*> toEnum 26) 
+                   (meetup <$> toEnum 2013 <*> toEnum 1 <@> Last <@> Saturday)
+
+    test "last Saturday of February 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 2 <*> toEnum 23) 
+                   (meetup <$> toEnum 2013 <*> toEnum 2 <@> Last <@> Saturday)
+
+    test "last Sunday of March 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 3 <*> toEnum 31) 
+                   (meetup <$> toEnum 2013 <*> toEnum 3 <@> Last <@> Sunday)
+
+    test "last Sunday of April 2013" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2013 <*> toEnum 4 <*> toEnum 28) 
+                   (meetup <$> toEnum 2013 <*> toEnum 4 <@> Last <@> Sunday)
+
+    test "last Wednesday of February 2012" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2012 <*> toEnum 2 <*> toEnum 29) 
+                   (meetup <$> toEnum 2012 <*> toEnum 2 <@> Last <@> Wednesday)
+
+    test "last Wednesday of December 2014" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2014 <*> toEnum 12 <*> toEnum 31) 
+                   (meetup <$> toEnum 2014 <*> toEnum 12 <@> Last <@> Wednesday)
+
+    test "last Sunday of February 2015" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2015 <*> toEnum 2 <*> toEnum 22) 
+                   (meetup <$> toEnum 2015 <*> toEnum 2 <@> Last <@> Sunday)
+
+    test "first Friday of December 2012" $
+      Assert.equal (Just $ canonicalDate <$> toEnum 2012 <*> toEnum 12 <*> toEnum 7) 
+                   (meetup <$> toEnum 2012 <*> toEnum 12 <@> First <@> Friday)

data/tracks/python/README.md

@@ -15,18 +15,19 @@ We welcome both improvements to the existing exercises and new exercises.
 A pool of exercise ideas can be found in the [x-common repo](https://github.com/exercism/x-common).
 
 All exercises must be compatible with Python versions 2.7 and 3.3 upwards.
-Therefore please test your changes at least with Python2.7 and Python3.5.
+Therefore please test your changes with these versions.
 
-To test a single exercise, say crypto-square, run:
+Test a single exercise with Python 2.7:
 ```
-python2.7 test/check-exercises.py crypto-square
+python2.7 test/check-exercises.py [exercise-name]
 ```
-and
+
+Test a single exercise with Python 3.3:
 ```
-python3.5 test/check-exercises.py crypto-square
+python3.3 test/check-exercises.py [exercise-name]
 ```
 
-To run the tests for all exercises type:
+Test all exercises:
 ```
 python test/check-exercises.py
 ```

data/tracks/python/docs/TOOLS.md

@@ -8,7 +8,7 @@ You can either start by creating your own project for working with the Exercism
 
 This is a Visual Studio template that comes pre-configured to work on the problems in as many languages as Visual Studio supports.
 
-![Solution Explorer](/img/SolutionExplorer.png)
+![Solution Explorer](/docs/img/SolutionExplorer.png)
 
 1. Download the [Exercism.io Visual Studio Template](https://github.com/rprouse/Exercism.VisualStudio) from GitHub by clicking the Download Zip button on the page.
 2. Unzip the template into your exercises directory, for example `C:\src\exercises`
@@ -23,11 +23,11 @@ This is a Visual Studio template that comes pre-configured to work on the proble
 10. The exercise you just fetched will appear greyed out. Right click on the folder and **Include In Project**
 11. Get coding...
 
-![Add files](/img/AddFiles.png)
+![Add files](/docs/img/AddFiles.png)
 
 To run the tests, you can do so at the command line, or within Visual Studio.
 
-![Test Explorer](/img/TestExplorer.png)
+![Test Explorer](/docs/img/TestExplorer.png)
 
 ## Code Style and Linting
 

data/tracks/python/exercises/bracket-push/bracket_push_test.py

@@ -3,34 +3,51 @@ import unittest
 from bracket_push import check_brackets
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class BracketPushTests(unittest.TestCase):
+    def test_paired_square_brackets(self):
+        self.assertEqual(check_brackets("[]"), True)
 
-    def test_input_empty(self):
+    def test_empty_string(self):
         self.assertEqual(check_brackets(""), True)
 
-    def test_single(self):
-        self.assertEqual(check_brackets("{}"), True)
-
-    def test_unclosed(self):
-        self.assertEqual(check_brackets("{{"), False)
+    def test_unpaired_brackets(self):
+        self.assertEqual(check_brackets("[["), False)
 
-    def test_wrong_order(self):
+    def test_wrong_ordered_brackets(self):
         self.assertEqual(check_brackets("}{"), False)
 
-    def test_mixed_not_nested(self):
-        self.assertEqual(check_brackets("{}[]"), True)
+    def test_paired_with_whitespace(self):
+        self.assertEqual(check_brackets("{ }"), True)
 
-    def test_mixed_nested(self):
+    def test_simple_nested_brackets(self):
         self.assertEqual(check_brackets("{[]}"), True)
 
-    def test_improperly_nested(self):
-        self.assertEqual(check_brackets("{[}]"), False)
+    def test_several_paired_brackets(self):
+        self.assertEqual(check_brackets("{}[]"), True)
+
+    def test_paired_and_nested_brackets(self):
+        self.assertEqual(check_brackets("([{}({}[])])"), True)
 
-    def test_not_opened_nested(self):
+    def test_unopened_closing_brackets(self):
         self.assertEqual(check_brackets("{[)][]}"), False)
 
-    def test_nested_ensemble(self):
-        self.assertEqual(check_brackets("{[]([()])}"), True)
+    def test_unpaired_and_nested_brackets(self):
+        self.assertEqual(check_brackets("([{])"), False)
+
+    def test_paired_and_wrong_nested_brackets(self):
+        self.assertEqual(check_brackets("[({]})"), False)
+
+    def test_math_expression(self):
+        self.assertEqual(
+            check_brackets("(((185 + 223.85) * 15) - 543)/2"), True)
+
+    def test_complex_latex_expression(self):
+        self.assertEqual(
+            check_brackets(
+                ("\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{"
+                 "x} &... x^2 \\end{array}\\right)")), True)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/hamming/hamming_test.py

@@ -3,6 +3,8 @@ import unittest
 import hamming
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class HammingTest(unittest.TestCase):
 
     def test_identical_strands(self):

data/tracks/python/exercises/luhn/luhn_test.py

@@ -5,6 +5,8 @@ import unittest
 from luhn import Luhn
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class LuhnTests(unittest.TestCase):
     def test_single_digit_strings_can_not_be_valid(self):
         self.assertFalse(Luhn("1").is_valid())

data/tracks/python/test/check-exercises.py

@@ -12,6 +12,10 @@ import tempfile
 import json
 
 
+def python_executable_name():
+    return 'python{}.{}'.format(sys.version_info.major, sys.version_info.minor)
+
+
 def check_assignment(name, test_file):
     # Returns the exit code of the tests
     workdir = tempfile.mkdtemp(name)
@@ -21,7 +25,7 @@ def check_assignment(name, test_file):
         shutil.copyfile(test_file, test_file_out)
         shutil.copyfile(os.path.join(os.path.dirname(test_file), 'example.py'),
                         os.path.join(workdir, '{}.py'.format(example_name)))
-        return subprocess.call(['python', test_file_out])
+        return subprocess.call([python_executable_name(), test_file_out])
     finally:
         shutil.rmtree(workdir)
 
@@ -91,6 +95,8 @@ def main():
                 failures.append('{} (TestFailed)'.format(exercise))
         print('')
 
+    print('TestEnvironment:', python_executable_name().capitalize(), end='\n\n')
+
     if failures:
         print('FAILURES: ', ', '.join(failures))
         raise SystemExit(1)