trackler 2.2.1.43 → 2.2.1.44

data/tracks/cfml/exercises/markdown/box.json

@@ -0,0 +1,8 @@
+{
+    "dependencies":{
+        "testbox":"^2.5.0+107"
+    },
+    "installPaths":{
+        "testbox":"testbox"
+    }
+}

data/tracks/cfml/exercises/markdown/index.cfm

@@ -0,0 +1,37 @@
+<!--- 
+
+This file will only be used if you want to start up a web server in this directory.  You can do so by running:
+
+$> box
+CommandBox> install
+CommandBox> server start
+
+However, this is not necessary unless you really just want to use the HTML reporters on TestBox.  
+Ideally, you'll skip the need for this file entirely and just run the tests directly frm the CLI like this:
+
+CommandBox> task run TestRunner
+
+ --->
+<cfsetting showDebugOutput="false">
+<cfparam name="url.reporter" 		default="simple">
+<cfscript>
+	// get a list of all CFCs in this folder whose name looks like "XXXTest.cfc"
+	// And turn it into compnent path relative to the web root
+	url.bundles = directoryList(
+			path=expandPath( '/' ),
+			filter='*Test.cfc' )
+		.map( function( path ) {
+			return path
+					.replaceNoCase( expandPath( '/' ), '' )
+					.left( -4 )
+		} )
+		.toList();
+</cfscript>
+
+<!--- Ensure TestBox --->
+<cfif fileExists( "/testbox/system/runners/HTMLRunner.cfm" )>
+	<!--- Include the TestBox HTML Runner --->
+	<cfinclude template="/testbox/system/runners/HTMLRunner.cfm">
+<cfelse>
+	Oops, you don't have TestBox installed yet! Please run <b>box install</b> from the root of your excercise folder and refresh this page.	
+</cfif>

data/tracks/csharp/exercises/dominoes/DominoesTest.cs

@@ -1,96 +1,91 @@
-using System;
+// This file was auto-generated based on version 2.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class DominoesTest
 {
     [Fact]
-    public void Empty_input_equals_empty_output()
+    public void Empty_input_empty_output()
     {
-        var actual = new Tuple<int, int>[0];
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] {  };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
-    public void Singleton_input_equals_singleton_output()
+    public void Singleton_input_singleton_output()
     {
-        var actual = new[] { Tuple.Create(1, 1) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 1) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Singleton_that_cant_be_chained()
     {
-        var actual = new[] { Tuple.Create(1, 2) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Three_elements()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(3, 1), Tuple.Create(2, 3) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(3, 1), Tuple.Create(2, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Can_reverse_dominoes()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(1, 3), Tuple.Create(2, 3) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(1, 3), Tuple.Create(2, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Cant_be_chained()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(4, 1), Tuple.Create(2, 3) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(4, 1), Tuple.Create(2, 3) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_simple()
     {
-        var actual = new[] { Tuple.Create(1, 1), Tuple.Create(2, 2) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 1), Tuple.Create(2, 2) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_double_loop()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 1), Tuple.Create(3, 4), Tuple.Create(4, 3) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 1), Tuple.Create(3, 4), Tuple.Create(4, 3) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Disconnected_single_isolated()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(4, 4) };
-        Assert.False(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(4, 4) };
+        Assert.False(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Need_backtrack()
     {
-        var actual = new[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(2, 4), Tuple.Create(2, 4) };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(2, 4), Tuple.Create(2, 4) };
+        Assert.True(Dominoes.CanChain(input));
     }
-    
+
     [Fact(Skip = "Remove to run test")]
     public void Separate_loops()
     {
-        var actual = new[]
-        {
-            Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(1, 1), Tuple.Create(2, 2), Tuple.Create(3, 3)
-        };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(2, 3), Tuple.Create(3, 1), Tuple.Create(1, 1), Tuple.Create(2, 2), Tuple.Create(3, 3) };
+        Assert.True(Dominoes.CanChain(input));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Ten_elements()
+    public void Nine_elements()
     {
-        var actual = new[]
-        {
-            Tuple.Create(1, 2), Tuple.Create(5, 3), Tuple.Create(3, 1), Tuple.Create(1, 2), Tuple.Create(2, 4),
-            Tuple.Create(1, 6), Tuple.Create(2, 3), Tuple.Create(3, 4), Tuple.Create(5, 6)
-        };
-        Assert.True(Dominoes.CanChain(actual));
+        var input = new Tuple<int, int>[] { Tuple.Create(1, 2), Tuple.Create(5, 3), Tuple.Create(3, 1), Tuple.Create(1, 2), Tuple.Create(2, 4), Tuple.Create(1, 6), Tuple.Create(2, 3), Tuple.Create(3, 4), Tuple.Create(5, 6) };
+        Assert.True(Dominoes.CanChain(input));
     }
 }

data/tracks/csharp/exercises/meetup/MeetupTest.cs

@@ -1,89 +1,767 @@
-using System;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class MeetupTest
 {
-    [Theory]
-    [InlineData(5, DayOfWeek.Monday, "2013-5-13")]
-    [InlineData(3, DayOfWeek.Tuesday, "2013-3-19")]
-    [InlineData(1, DayOfWeek.Wednesday, "2013-1-16")]
-    [InlineData(5, DayOfWeek.Thursday, "2013-5-16")]
-    [InlineData(4, DayOfWeek.Friday, "2013-4-19")]
-    [InlineData(2, DayOfWeek.Saturday, "2013-2-16")]
-    [InlineData(10, DayOfWeek.Sunday, "2013-10-13")]
-    public void Finds_first_teenth_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.Teenth);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
-    }
-
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3, DayOfWeek.Monday, "2013-3-4")]
-    [InlineData(5, DayOfWeek.Tuesday, "2013-5-7")]
-    [InlineData(7, DayOfWeek.Wednesday, "2013-7-3")]
-    [InlineData(9, DayOfWeek.Thursday, "2013-9-5")]
-    [InlineData(11, DayOfWeek.Friday, "2013-11-1")]
-    [InlineData(1, DayOfWeek.Saturday, "2013-1-5")]
-    [InlineData(4, DayOfWeek.Sunday, "2013-4-7")]
-    public void Finds_first_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.First);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
-    }
-
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3, DayOfWeek.Monday, "2013-3-11")]
-    [InlineData(5, DayOfWeek.Tuesday, "2013-5-14")]
-    [InlineData(7, DayOfWeek.Wednesday, "2013-7-10")]
-    [InlineData(9, DayOfWeek.Thursday, "2013-9-12")]
-    [InlineData(12, DayOfWeek.Friday, "2013-12-13")]
-    [InlineData(2, DayOfWeek.Saturday, "2013-2-9")]
-    [InlineData(4, DayOfWeek.Sunday, "2013-4-14")]
-    public void Finds_second_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.Second);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
-    }
-
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3, DayOfWeek.Monday, "2013-3-18")]
-    [InlineData(5, DayOfWeek.Tuesday, "2013-5-21")]
-    [InlineData(7, DayOfWeek.Wednesday, "2013-7-17")]
-    [InlineData(9, DayOfWeek.Thursday, "2013-9-19")]
-    [InlineData(12, DayOfWeek.Friday, "2013-12-20")]
-    [InlineData(2, DayOfWeek.Saturday, "2013-2-16")]
-    [InlineData(4, DayOfWeek.Sunday, "2013-4-21")]
-    public void Finds_third_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.Third);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
-    }
-
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3, DayOfWeek.Monday, "2013-3-25")]
-    [InlineData(5, DayOfWeek.Tuesday, "2013-5-28")]
-    [InlineData(7, DayOfWeek.Wednesday, "2013-7-24")]
-    [InlineData(9, DayOfWeek.Thursday, "2013-9-26")]
-    [InlineData(12, DayOfWeek.Friday, "2013-12-27")]
-    [InlineData(2, DayOfWeek.Saturday, "2013-2-23")]
-    [InlineData(4, DayOfWeek.Sunday, "2013-4-28")]
-    public void Finds_fourth_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.Fourth);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
-    }
-
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(3, DayOfWeek.Monday, "2013-3-25")]
-    [InlineData(5, DayOfWeek.Tuesday, "2013-5-28")]
-    [InlineData(7, DayOfWeek.Wednesday, "2013-7-31")]
-    [InlineData(9, DayOfWeek.Thursday, "2013-9-26")]
-    [InlineData(12, DayOfWeek.Friday, "2013-12-27")]
-    [InlineData(2, DayOfWeek.Saturday, "2013-2-23")]
-    [InlineData(3, DayOfWeek.Sunday, "2013-3-31")]
-    public void Finds_last_day_of_week_in_a_month(int month, DayOfWeek dayOfWeek, string expected)
-    {
-        DateTime day = new Meetup(month, 2013).Day(dayOfWeek, Schedule.Last);
-        Assert.Equal(expected, day.ToString("yyyy-M-d"));
+    [Fact]
+    public void Monteenth_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Monteenth_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Monteenth_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Tuesteenth_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Tuesteenth_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Tuesteenth_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Wednesteenth_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Wednesteenth_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Wednesteenth_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Thursteenth_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Thursteenth_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Thursteenth_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Friteenth_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Friteenth_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Friteenth_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Saturteenth_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Saturteenth_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Saturteenth_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Sunteenth_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Sunteenth_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Sunteenth_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Teenth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_monday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-4";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_monday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-1";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_tuesday_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-7";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_tuesday_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-4";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_wednesday_of_july_2013()
+    {
+        var sut = new Meetup(7, 2013);
+        var expected = "2013-7-3";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_wednesday_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-7";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_thursday_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-5";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_thursday_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-3";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_friday_of_november_2013()
+    {
+        var sut = new Meetup(11, 2013);
+        var expected = "2013-11-1";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_friday_of_december_2013()
+    {
+        var sut = new Meetup(12, 2013);
+        var expected = "2013-12-6";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_saturday_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-5";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_saturday_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-2";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_sunday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-3";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_sunday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-7";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.First).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_monday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-11";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_monday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-8";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_tuesday_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-14";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_tuesday_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-11";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_wednesday_of_july_2013()
+    {
+        var sut = new Meetup(7, 2013);
+        var expected = "2013-7-10";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_wednesday_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-14";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_thursday_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-12";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_thursday_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-10";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_friday_of_november_2013()
+    {
+        var sut = new Meetup(11, 2013);
+        var expected = "2013-11-8";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_friday_of_december_2013()
+    {
+        var sut = new Meetup(12, 2013);
+        var expected = "2013-12-13";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_saturday_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-12";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_saturday_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-9";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_sunday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-10";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_sunday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-14";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Second).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_monday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-18";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_monday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-15";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_tuesday_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-21";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_tuesday_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-18";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_wednesday_of_july_2013()
+    {
+        var sut = new Meetup(7, 2013);
+        var expected = "2013-7-17";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_wednesday_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-21";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_thursday_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_thursday_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-17";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_friday_of_november_2013()
+    {
+        var sut = new Meetup(11, 2013);
+        var expected = "2013-11-15";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_friday_of_december_2013()
+    {
+        var sut = new Meetup(12, 2013);
+        var expected = "2013-12-20";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_saturday_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-19";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_saturday_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-16";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_sunday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-17";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Third_sunday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-21";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Third).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_monday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-25";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_monday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-22";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_tuesday_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_tuesday_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-25";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_wednesday_of_july_2013()
+    {
+        var sut = new Meetup(7, 2013);
+        var expected = "2013-7-24";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_wednesday_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_thursday_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-26";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_thursday_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-24";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_friday_of_november_2013()
+    {
+        var sut = new Meetup(11, 2013);
+        var expected = "2013-11-22";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_friday_of_december_2013()
+    {
+        var sut = new Meetup(12, 2013);
+        var expected = "2013-12-27";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_saturday_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-26";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_saturday_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-23";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_sunday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-24";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Fourth_sunday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Fourth).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_monday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-25";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_monday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-29";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Monday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_tuesday_of_may_2013()
+    {
+        var sut = new Meetup(5, 2013);
+        var expected = "2013-5-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_tuesday_of_june_2013()
+    {
+        var sut = new Meetup(6, 2013);
+        var expected = "2013-6-25";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Tuesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_wednesday_of_july_2013()
+    {
+        var sut = new Meetup(7, 2013);
+        var expected = "2013-7-31";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_wednesday_of_august_2013()
+    {
+        var sut = new Meetup(8, 2013);
+        var expected = "2013-8-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_thursday_of_september_2013()
+    {
+        var sut = new Meetup(9, 2013);
+        var expected = "2013-9-26";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_thursday_of_october_2013()
+    {
+        var sut = new Meetup(10, 2013);
+        var expected = "2013-10-31";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Thursday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_friday_of_november_2013()
+    {
+        var sut = new Meetup(11, 2013);
+        var expected = "2013-11-29";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_friday_of_december_2013()
+    {
+        var sut = new Meetup(12, 2013);
+        var expected = "2013-12-27";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_saturday_of_january_2013()
+    {
+        var sut = new Meetup(1, 2013);
+        var expected = "2013-1-26";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_saturday_of_february_2013()
+    {
+        var sut = new Meetup(2, 2013);
+        var expected = "2013-2-23";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Saturday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_sunday_of_march_2013()
+    {
+        var sut = new Meetup(3, 2013);
+        var expected = "2013-3-31";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_sunday_of_april_2013()
+    {
+        var sut = new Meetup(4, 2013);
+        var expected = "2013-4-28";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_wednesday_of_february_2012()
+    {
+        var sut = new Meetup(2, 2012);
+        var expected = "2012-2-29";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_wednesday_of_december_2014()
+    {
+        var sut = new Meetup(12, 2014);
+        var expected = "2014-12-31";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Wednesday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Last_sunday_of_february_2015()
+    {
+        var sut = new Meetup(2, 2015);
+        var expected = "2015-2-22";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Sunday, Schedule.Last).ToString("yyyy-M-d"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void First_friday_of_december_2012()
+    {
+        var sut = new Meetup(12, 2012);
+        var expected = "2012-12-7";
+        Assert.Equal(expected, sut.Day(DayOfWeek.Friday, Schedule.First).ToString("yyyy-M-d"));
     }
 }