trackler 2.0.6.17 → 2.0.6.18

data/tracks/java/exercises/phone-number/src/example/java/PhoneNumber.java

@@ -11,13 +11,20 @@ public class PhoneNumber {
     }
 
     private String normalize(String number) {
-        if(number.length() == 11 && number.startsWith("1")) {
-            number = number.substring(1, number.length());
+        if(number.length() > 11 || number.length() < 10){
+            throw new IllegalArgumentException("Number must be 10 or 11 digits");
         }
 
-        final boolean numberIsValid = (number.length() == 10);
-        final String normalizedNumber = numberIsValid ? number : "0000000000";
-        return normalizedNumber;
+        if(number.length() == 11){
+            if(number.startsWith("1")){
+                number = number.substring(1, number.length());
+            }
+            else{
+                throw new IllegalArgumentException("Can only have 11 digits if number starts with '1'");
+            }
+        } 
+        
+        return number;
     }
 
     public String getNumber() {

data/tracks/java/exercises/phone-number/src/test/java/PhoneNumberTest.java

@@ -1,10 +1,14 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.*;
 
 public class PhoneNumberTest {
 
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
 
     @Test
     public void cleansNumber() {
@@ -41,23 +45,17 @@ public class PhoneNumberTest {
     @Ignore
     @Test
     public void invalidWhenOnly11Digits() {
-        final String expectedNumber = "0000000000";
-        final String actualNumber = new PhoneNumber("21234567890").getNumber();
-
-        assertEquals(
-            expectedNumber, actualNumber
-        );
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Can only have 11 digits if number starts with '1'");
+        new PhoneNumber("21234567890").getNumber();
     }
 
     @Ignore
     @Test
     public void invalidWhen9Digits() {
-        final String expectedNumber = "0000000000";
-        final String actualNumber = new PhoneNumber("123456789").getNumber();
-
-        assertEquals(
-            expectedNumber, actualNumber
-        );
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Number must be 10 or 11 digits");
+        new PhoneNumber("123456789").getNumber();
     }
 
     @Ignore

data/tracks/julia/config.json

@@ -13,7 +13,8 @@
   "ignored": [
     "bin",
     "img",
-    "docs"
+    "docs",
+    "juliamnt"
   ],
   "foregone": [
 

data/tracks/julia/runtests.jl

@@ -16,14 +16,16 @@ for (root, dirs, files) in walkdir("exercises")
         cp(joinpath(exercise_path, "example.jl"), joinpath(temp_path, "$exercise.jl"))
         cp(joinpath(exercise_path, "runtests.jl"), joinpath(temp_path, "runtests.jl"))
 
-        # Run the tests
-        result = @testset "$exercise example" begin
-            include(joinpath(temp_path, "runtests.jl"))
+        try
+            # Run the tests
+            result = @testset "$exercise example" begin
+                include(joinpath(temp_path, "runtests.jl"))
+            end
+        finally
+            # Delete the temporary directory
+            rm(temp_path, recursive=true)
         end
 
-        # Delete the temporary directory
-        rm(temp_path, recursive=true)
-
         # Print test output (this is the default behaviour for older versions of Julia)
         if VERSION > v"0.6.0-dev"
             Base.Test.print_test_results(result)

data/tracks/kotlin/exercises/rna-transcription/src/main/kotlin/RnaTranscription.kt

@@ -1,9 +1 @@
-/*
-  In Kotlin functions can be declared at top level in a file, meaning
-  you do not need to create a class to hold a function, like languages
-  such as Java, C# or Scala.
-
-  http://kotlinlang.org/docs/reference/functions.html#function-scope
- */
-
 fun transcribeToRna(dna: String): String = ""

data/tracks/kotlin/exercises/rna-transcription/src/test/kotlin/RnaTranscriptionTest.kt

@@ -3,6 +3,15 @@ import org.junit.Test;
 
 class RnaTranscriptionTest {
 
+    /*
+      In Kotlin functions can be declared at top level in a file, meaning
+      you do not need to create a class to hold a function, like languages
+      such as Java, C# or Scala.
+
+      http://kotlinlang.org/docs/reference/functions.html#function-scope
+
+     */
+
     @Test
     fun emptyDnaIsEmptyRna() {
         Assert.assertEquals("", transcribeToRna(""));

data/tracks/scala/config.json

@@ -110,6 +110,9 @@
       "slug": "space-age",
       "difficulty": 1,
       "topics": [
+        "Dates",
+        "Enumerations",
+        "Domain-specific languages"
       ]
 		},
     {

data/tracks/scala/exercises/meetup/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/meetup/example.scala

@@ -1,44 +1,33 @@
-import java.util.{Calendar, GregorianCalendar}
+import java.time.DayOfWeek
+import java.time.LocalDate
 
 case class Meetup(month: Int, year: Int) {
-  private val thirteenth = new GregorianCalendar(year, month - 1, 13)
-  private val first = new GregorianCalendar(year, month - 1, 1)
-  private val nextMonth = first.addMonths(1)
+  private val thirteenth = LocalDate.of(year, month, 13)
+  private val first = LocalDate.of(year, month, 1)
+  private val nextMonth = first.plusMonths(1)
 
-  def teenth(day: Int): Calendar = thirteenth.next(day)
-  def first(day: Int): Calendar = first.next(day)
-  def second(day: Int): Calendar = first(day).addDays(7)
-  def third(day: Int): Calendar = second(day).addDays(7)
-  def fourth(day: Int): Calendar = third(day).addDays(7)
-  def last(day: Int): Calendar = nextMonth.next(day).addDays(-7)
+  def teenth(day: Int): LocalDate = thirteenth.next(day)
+  def first(day: Int): LocalDate = first.next(day)
+  def second(day: Int): LocalDate = first(day).plusDays(7)
+  def third(day: Int): LocalDate = second(day).plusDays(7)
+  def fourth(day: Int): LocalDate = third(day).plusDays(7)
+  def last(day: Int): LocalDate = nextMonth.next(day).minusDays(7)
 
-  implicit class ImmutableCalendar(calendar: Calendar) {
-    def next(dayOfWeek: Int): Calendar = addDays(daysUntil(dayOfWeek))
+  implicit class LocalDateOps(self: LocalDate) {
+    def next(dayOfWeek: Int): LocalDate = self.plusDays(daysUntil(dayOfWeek))
 
-    def addDays(count: Int): Calendar = copyAnd(_.add(Calendar.DAY_OF_YEAR, count))
+    def daysUntil(dayOfWeek: Int): Int = (Meetup.Sun - this.dayOfWeek + dayOfWeek) % 7
 
-    def addMonths(count: Int): Calendar = copyAnd(_.add(Calendar.MONTH, count))
-
-    def daysUntil(dayOfWeek: Int): Int = (Meetup.Sat - this.dayOfWeek + dayOfWeek) % 7
-
-    def dayOfWeek: Int = calendar.get(Calendar.DAY_OF_WEEK)
-
-    private def copy: Calendar = calendar.clone.asInstanceOf[Calendar]
-
-    private def copyAnd(f: Calendar => Unit) = {
-      val c = copy
-      f(c)
-      c
-    }
+    def dayOfWeek: Int = self.getDayOfWeek.getValue
   }
 }
 
 object Meetup {
-  val Mon = Calendar.MONDAY
-  val Tue = Calendar.TUESDAY
-  val Wed = Calendar.WEDNESDAY
-  val Thu = Calendar.THURSDAY
-  val Fri = Calendar.FRIDAY
-  val Sat = Calendar.SATURDAY
-  val Sun = Calendar.SUNDAY
+  val Mon = DayOfWeek.MONDAY.getValue
+  val Tue = DayOfWeek.TUESDAY.getValue
+  val Wed = DayOfWeek.WEDNESDAY.getValue
+  val Thu = DayOfWeek.THURSDAY.getValue
+  val Fri = DayOfWeek.FRIDAY.getValue
+  val Sat = DayOfWeek.SATURDAY.getValue
+  val Sun = DayOfWeek.SUNDAY.getValue
 }

data/tracks/scala/exercises/meetup/src/test/scala/MeetupTest.scala

@@ -1,221 +1,460 @@
+import java.time.LocalDate
 import org.scalatest._
-import java.util.GregorianCalendar
 
 class MeetupTest extends FunSuite with Matchers {
   //Note: Java uses 0-indexed months for GregorianCalendar
   test ("monteenth of may 2013") {
-    Meetup(5, 2013).teenth(Meetup.Mon) should be (new GregorianCalendar(2013, 4, 13))
+    Meetup(5, 2013).teenth(Meetup.Mon) should be (LocalDate.of(2013, 5, 13))
   }
 
-  test ("teenth respects month") {
+  test ("monteenth of august 2013") {
     pending
-    Meetup(8, 2013).teenth(Meetup.Mon) should be (new GregorianCalendar(2013, 7, 19))
+    Meetup(8, 2013).teenth(Meetup.Mon) should be (LocalDate.of(2013, 8, 19))
   }
 
-  test ("teenth respects year") {
+  test ("monteenth of september 2013") {
     pending
-    Meetup(8, 2016).teenth(Meetup.Mon) should be (new GregorianCalendar(2016, 7, 15))
+    Meetup(9, 2013).teenth(Meetup.Mon) should be (LocalDate.of(2013, 9, 16))
   }
 
-  test ("teenth respects weekday") {
+  test ("tuesteenth of march 2013") {
     pending
-    Meetup(3, 2013).teenth(Meetup.Tue) should be (new GregorianCalendar(2013, 2, 19))
+    Meetup(3, 2013).teenth(Meetup.Tue) should be (LocalDate.of(2013, 3, 19))
   }
 
-  test ("teenth works on a variety of dates") {
+  test ("tuesteenth of april 2013") {
     pending
-    Meetup(4, 2013).teenth(Meetup.Tue) should be (new GregorianCalendar(2013, 3, 16))
-    Meetup(8, 2013).teenth(Meetup.Tue) should be (new GregorianCalendar(2013, 7, 13))
-    Meetup(1, 2013).teenth(Meetup.Wed) should be (new GregorianCalendar(2013, 0, 16))
-    Meetup(2, 2013).teenth(Meetup.Wed) should be (new GregorianCalendar(2013, 1, 13))
-    Meetup(6, 2013).teenth(Meetup.Wed) should be (new GregorianCalendar(2013, 5, 19))
-    Meetup(5, 2013).teenth(Meetup.Thu) should be (new GregorianCalendar(2013, 4, 16))
-    Meetup(6, 2013).teenth(Meetup.Thu) should be (new GregorianCalendar(2013, 5, 13))
-    Meetup(9, 2013).teenth(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 19))
-    Meetup(4, 2013).teenth(Meetup.Fri) should be (new GregorianCalendar(2013, 3, 19))
-    Meetup(8, 2013).teenth(Meetup.Fri) should be (new GregorianCalendar(2013, 7, 16))
-    Meetup(9, 2013).teenth(Meetup.Fri) should be (new GregorianCalendar(2013, 8, 13))
-    Meetup(2, 2013).teenth(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 16))
-    Meetup(4, 2013).teenth(Meetup.Sat) should be (new GregorianCalendar(2013, 3, 13))
-    Meetup(10, 2013).teenth(Meetup.Sat) should be (new GregorianCalendar(2013, 9, 19))
-    Meetup(5, 2013).teenth(Meetup.Sun) should be (new GregorianCalendar(2013, 4, 19))
-    Meetup(6, 2013).teenth(Meetup.Sun) should be (new GregorianCalendar(2013, 5, 16))
-    Meetup(10, 2013).teenth(Meetup.Sun) should be (new GregorianCalendar(2013, 9, 13))
+    Meetup(4, 2013).teenth(Meetup.Tue) should be (LocalDate.of(2013, 4, 16))
+  }
+
+  test ("tuesteenth of august 2013") {
+    pending
+    Meetup(8, 2013).teenth(Meetup.Tue) should be (LocalDate.of(2013, 8, 13))
+  }
+
+  test ("wednesteenth of january 2013") {
+    pending
+    Meetup(1, 2013).teenth(Meetup.Wed) should be (LocalDate.of(2013, 1, 16))
+  }
+
+  test ("wednesteenth of february 2013") {
+    pending
+    Meetup(2, 2013).teenth(Meetup.Wed) should be (LocalDate.of(2013, 2, 13))
+  }
+
+  test ("wednesteenth of june 2013") {
+    pending
+    Meetup(6, 2013).teenth(Meetup.Wed) should be (LocalDate.of(2013, 6, 19))
+  }
+
+  test ("thursteenth of may 2013") {
+    pending
+    Meetup(5, 2013).teenth(Meetup.Thu) should be (LocalDate.of(2013, 5, 16))
+  }
+
+  test ("thursteenth of june 2013") {
+    pending
+    Meetup(6, 2013).teenth(Meetup.Thu) should be (LocalDate.of(2013, 6, 13))
+  }
+
+  test ("thursteenth of september 2013") {
+    pending
+    Meetup(9, 2013).teenth(Meetup.Thu) should be (LocalDate.of(2013, 9, 19))
+  }
+
+  test ("friteenth of april 2013") {
+    pending
+    Meetup(4, 2013).teenth(Meetup.Fri) should be (LocalDate.of(2013, 4, 19))
+  }
+
+  test ("friteenth of august 2013") {
+    pending
+    Meetup(8, 2013).teenth(Meetup.Fri) should be (LocalDate.of(2013, 8, 16))
+  }
+
+  test ("friteenth of september 2013") {
+    pending
+    Meetup(9, 2013).teenth(Meetup.Fri) should be (LocalDate.of(2013, 9, 13))
+  }
+
+  test ("saturteenth of february 2013") {
+    pending
+    Meetup(2, 2013).teenth(Meetup.Sat) should be (LocalDate.of(2013, 2, 16))
+  }
+
+  test ("saturteenth of april 2013") {
+    pending
+    Meetup(4, 2013).teenth(Meetup.Sat) should be (LocalDate.of(2013, 4, 13))
+  }
+
+  test ("saturteenth of october 2013") {
+    pending
+    Meetup(10, 2013).teenth(Meetup.Sat) should be (LocalDate.of(2013, 10, 19))
+  }
+
+  test ("sunteenth of may 2013") {
+    pending
+    Meetup(5, 2013).teenth(Meetup.Sun) should be (LocalDate.of(2013, 5, 19))
+  }
+
+  test ("sunteenth of june 2013") {
+    pending
+    Meetup(6, 2013).teenth(Meetup.Sun) should be (LocalDate.of(2013, 6, 16))
+  }
+
+  test ("sunteenth of october 2013") {
+    pending
+    Meetup(10, 2013).teenth(Meetup.Sun) should be (LocalDate.of(2013, 10, 13))
   }
 
   test ("first monday of march 2013") {
     pending
-    Meetup(3, 2013).first(Meetup.Mon) should be (new GregorianCalendar(2013, 2, 4))
+    Meetup(3, 2013).first(Meetup.Mon) should be (LocalDate.of(2013, 3, 4))
+  }
+
+  test ("first monday of april 2013") {
+    pending
+    Meetup(4, 2013).first(Meetup.Mon) should be (LocalDate.of(2013, 4, 1))
+  }
+
+  test ("first tuesday of may 2013") {
+    pending
+    Meetup(5, 2013).first(Meetup.Tue) should be (LocalDate.of(2013, 5, 7))
+  }
+
+  test ("first tuesday of june 2013") {
+    pending
+    Meetup(6, 2013).first(Meetup.Tue) should be (LocalDate.of(2013, 6, 4))
+  }
+
+  test ("first wednesday of july 2013") {
+    pending
+    Meetup(7, 2013).first(Meetup.Wed) should be (LocalDate.of(2013, 7, 3))
+  }
+
+  test ("first wednesday of august 2013") {
+    pending
+    Meetup(8, 2013).first(Meetup.Wed) should be (LocalDate.of(2013, 8, 7))
+  }
+
+  test ("first thursday of september 2013") {
+    pending
+    Meetup(9, 2013).first(Meetup.Thu) should be (LocalDate.of(2013, 9, 5))
+  }
+
+  test ("first thursday of october 2013") {
+    pending
+    Meetup(10, 2013).first(Meetup.Thu) should be (LocalDate.of(2013, 10, 3))
   }
 
-  test ("first respects month") {
+  test ("first friday of november 2013") {
     pending
-    Meetup(4, 2013).first(Meetup.Mon) should be (new GregorianCalendar(2013, 3, 1))
+    Meetup(11, 2013).first(Meetup.Fri) should be (LocalDate.of(2013, 11, 1))
   }
 
-  test ("first respects year") {
+  test ("first friday of december 2013") {
     pending
-    Meetup(5, 2016).first(Meetup.Mon) should be (new GregorianCalendar(2016, 4, 2))
+    Meetup(12, 2013).first(Meetup.Fri) should be (LocalDate.of(2013, 12, 6))
   }
 
-  test ("first respects weekday") {
+  test ("first saturday of january 2013") {
     pending
-    Meetup(6, 2013).first(Meetup.Tue) should be (new GregorianCalendar(2013, 5, 4))
+    Meetup(1, 2013).first(Meetup.Sat) should be (LocalDate.of(2013, 1, 5))
   }
 
-  test ("first works on a variety of dates") {
+  test ("first saturday of february 2013") {
     pending
-    Meetup(7, 2013).first(Meetup.Wed) should be (new GregorianCalendar(2013, 6, 3))
-    Meetup(8, 2013).first(Meetup.Wed) should be (new GregorianCalendar(2013, 7, 7))
-    Meetup(9, 2013).first(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 5))
-    Meetup(10, 2013).first(Meetup.Thu) should be (new GregorianCalendar(2013, 9, 3))
-    Meetup(11, 2013).first(Meetup.Fri) should be (new GregorianCalendar(2013, 10, 1))
-    Meetup(12, 2013).first(Meetup.Fri) should be (new GregorianCalendar(2013, 11, 6))
-    Meetup(1, 2013).first(Meetup.Sat) should be (new GregorianCalendar(2013, 0, 5))
-    Meetup(2, 2013).first(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 2))
-    Meetup(3, 2013).first(Meetup.Sun) should be (new GregorianCalendar(2013, 2, 3))
-    Meetup(4, 2013).first(Meetup.Sun) should be (new GregorianCalendar(2013, 3, 7))
+    Meetup(2, 2013).first(Meetup.Sat) should be (LocalDate.of(2013, 2, 2))
+  }
+
+  test ("first sunday of march 2013") {
+    pending
+    Meetup(3, 2013).first(Meetup.Sun) should be (LocalDate.of(2013, 3, 3))
+  }
+
+  test ("first sunday of april 2013") {
+    pending
+    Meetup(4, 2013).first(Meetup.Sun) should be (LocalDate.of(2013, 4, 7))
   }
 
   test ("second monday of march 2013") {
     pending
-    Meetup(3, 2013).second(Meetup.Mon) should be (new GregorianCalendar(2013, 2, 11))
+    Meetup(3, 2013).second(Meetup.Mon) should be (LocalDate.of(2013, 3, 11))
+  }
+
+  test ("second monday of april 2013") {
+    pending
+    Meetup(4, 2013).second(Meetup.Mon) should be (LocalDate.of(2013, 4, 8))
+  }
+
+  test ("second tuesday of may 2013") {
+    pending
+    Meetup(5, 2013).second(Meetup.Tue) should be (LocalDate.of(2013, 5, 14))
+  }
+
+  test ("second tuesday of june 2013") {
+    pending
+    Meetup(6, 2013).second(Meetup.Tue) should be (LocalDate.of(2013, 6, 11))
   }
 
-  test ("second respects month") {
+  test ("second wednesday of july 2013") {
     pending
-    Meetup(4, 2013).second(Meetup.Mon) should be (new GregorianCalendar(2013, 3, 8))
+    Meetup(7, 2013).second(Meetup.Wed) should be (LocalDate.of(2013, 7, 10))
   }
 
-  test ("second respects year") {
+  test ("second wednesday of august 2013") {
     pending
-    Meetup(5, 2016).second(Meetup.Mon) should be (new GregorianCalendar(2016, 4, 9))
+    Meetup(8, 2013).second(Meetup.Wed) should be (LocalDate.of(2013, 8, 14))
   }
 
-  test ("second respects weekday") {
+  test ("second thursday of september 2013") {
     pending
-    Meetup(6, 2013).second(Meetup.Tue) should be (new GregorianCalendar(2013, 5, 11))
+    Meetup(9, 2013).second(Meetup.Thu) should be (LocalDate.of(2013, 9, 12))
   }
 
-  test ("second works on a variety of dates") {
+  test ("second thursday of october 2013") {
     pending
-    Meetup(7, 2013).second(Meetup.Wed) should be (new GregorianCalendar(2013, 6, 10))
-    Meetup(8, 2013).second(Meetup.Wed) should be (new GregorianCalendar(2013, 7, 14))
-    Meetup(9, 2013).second(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 12))
-    Meetup(10, 2013).second(Meetup.Thu) should be (new GregorianCalendar(2013, 9, 10))
-    Meetup(11, 2013).second(Meetup.Fri) should be (new GregorianCalendar(2013, 10, 8))
-    Meetup(12, 2013).second(Meetup.Fri) should be (new GregorianCalendar(2013, 11, 13))
-    Meetup(1, 2013).second(Meetup.Sat) should be (new GregorianCalendar(2013, 0, 12))
-    Meetup(2, 2013).second(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 9))
-    Meetup(3, 2013).second(Meetup.Sun) should be (new GregorianCalendar(2013, 2, 10))
-    Meetup(4, 2013).second(Meetup.Sun) should be (new GregorianCalendar(2013, 3, 14))
+    Meetup(10, 2013).second(Meetup.Thu) should be (LocalDate.of(2013, 10, 10))
+  }
+
+  test ("second friday of november 2013") {
+    pending
+    Meetup(11, 2013).second(Meetup.Fri) should be (LocalDate.of(2013, 11, 8))
+  }
+
+  test ("second friday of december 2013") {
+    pending
+    Meetup(12, 2013).second(Meetup.Fri) should be (LocalDate.of(2013, 12, 13))
+  }
+
+  test ("second saturday of january 2013") {
+    pending
+    Meetup(1, 2013).second(Meetup.Sat) should be (LocalDate.of(2013, 1, 12))
+  }
+
+  test ("second saturday of february 2013") {
+    pending
+    Meetup(2, 2013).second(Meetup.Sat) should be (LocalDate.of(2013, 2, 9))
+  }
+
+  test ("second sunday of march 2013") {
+    pending
+    Meetup(3, 2013).second(Meetup.Sun) should be (LocalDate.of(2013, 3, 10))
+  }
+
+  test ("second sunday of april 2013") {
+    pending
+    Meetup(4, 2013).second(Meetup.Sun) should be (LocalDate.of(2013, 4, 14))
   }
 
   test ("third monday of march 2013") {
     pending
-    Meetup(3, 2013).third(Meetup.Mon) should be (new GregorianCalendar(2013, 2, 18))
+    Meetup(3, 2013).third(Meetup.Mon) should be (LocalDate.of(2013, 3, 18))
+  }
+
+  test ("third monday of april 2013") {
+    pending
+    Meetup(4, 2013).third(Meetup.Mon) should be (LocalDate.of(2013, 4, 15))
+  }
+
+  test ("third tuesday of may 2013") {
+    pending
+    Meetup(5, 2013).third(Meetup.Tue) should be (LocalDate.of(2013, 5, 21))
+  }
+
+  test ("third tuesday of june 2013") {
+    pending
+    Meetup(6, 2013).third(Meetup.Tue) should be (LocalDate.of(2013, 6, 18))
+  }
+
+  test ("third wednesday of july 2013") {
+    pending
+    Meetup(7, 2013).third(Meetup.Wed) should be (LocalDate.of(2013, 7, 17))
   }
 
-  test ("third respects month") {
+  test ("third wednesday of august 2013") {
     pending
-    Meetup(4, 2013).third(Meetup.Mon) should be (new GregorianCalendar(2013, 3, 15))
+    Meetup(8, 2013).third(Meetup.Wed) should be (LocalDate.of(2013, 8, 21))
   }
 
-  test ("third respects year") {
+  test ("third thursday of september 2013") {
     pending
-    Meetup(5, 2016).third(Meetup.Mon) should be (new GregorianCalendar(2016, 4, 16))
+    Meetup(9, 2013).third(Meetup.Thu) should be (LocalDate.of(2013, 9, 19))
   }
 
-  test ("third respects weekday") {
+  test ("third thursday of october 2013") {
     pending
-    Meetup(6, 2013).third(Meetup.Tue) should be (new GregorianCalendar(2013, 5, 18))
+    Meetup(10, 2013).third(Meetup.Thu) should be (LocalDate.of(2013, 10, 17))
   }
 
-  test ("third works for a variety of dates") {
+  test ("third friday of november 2013") {
     pending
-    Meetup(7, 2013).third(Meetup.Wed) should be (new GregorianCalendar(2013, 6, 17))
-    Meetup(8, 2013).third(Meetup.Wed) should be (new GregorianCalendar(2013, 7, 21))
-    Meetup(9, 2013).third(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 19))
-    Meetup(10, 2013).third(Meetup.Thu) should be (new GregorianCalendar(2013, 9, 17))
-    Meetup(11, 2013).third(Meetup.Fri) should be (new GregorianCalendar(2013, 10, 15))
-    Meetup(12, 2013).third(Meetup.Fri) should be (new GregorianCalendar(2013, 11, 20))
-    Meetup(1, 2013).third(Meetup.Sat) should be (new GregorianCalendar(2013, 0, 19))
-    Meetup(2, 2013).third(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 16))
-    Meetup(3, 2013).third(Meetup.Sun) should be (new GregorianCalendar(2013, 2, 17))
-    Meetup(4, 2013).third(Meetup.Sun) should be (new GregorianCalendar(2013, 3, 21))
+    Meetup(11, 2013).third(Meetup.Fri) should be (LocalDate.of(2013, 11, 15))
+  }
+
+  test ("third friday of december 2013") {
+    pending
+    Meetup(12, 2013).third(Meetup.Fri) should be (LocalDate.of(2013, 12, 20))
+  }
+
+  test ("third saturday of january 2013") {
+    pending
+    Meetup(1, 2013).third(Meetup.Sat) should be (LocalDate.of(2013, 1, 19))
+  }
+
+  test ("third saturday of february 2013") {
+    pending
+    Meetup(2, 2013).third(Meetup.Sat) should be (LocalDate.of(2013, 2, 16))
+  }
+
+  test ("third sunday of march 2013") {
+    pending
+    Meetup(3, 2013).third(Meetup.Sun) should be (LocalDate.of(2013, 3, 17))
+  }
+
+  test ("third sunday of april 2013") {
+    pending
+    Meetup(4, 2013).third(Meetup.Sun) should be (LocalDate.of(2013, 4, 21))
   }
 
   test ("fourth monday of march 2013") {
     pending
-    Meetup(3, 2013).fourth(Meetup.Mon) should be (new GregorianCalendar(2013, 2, 25))
+    Meetup(3, 2013).fourth(Meetup.Mon) should be (LocalDate.of(2013, 3, 25))
+  }
+
+  test ("fourth monday of april 2013") {
+    pending
+    Meetup(4, 2013).fourth(Meetup.Mon) should be (LocalDate.of(2013, 4, 22))
+  }
+
+  test ("fourth tuesday of may 2013") {
+    pending
+    Meetup(5, 2013).fourth(Meetup.Tue) should be (LocalDate.of(2013, 5, 28))
+  }
+
+  test ("fourth tuesday of june 2013") {
+    pending
+    Meetup(6, 2013).fourth(Meetup.Tue) should be (LocalDate.of(2013, 6, 25))
+  }
+
+  test ("fourth wednesday of july 2013") {
+    pending
+    Meetup(7, 2013).fourth(Meetup.Wed) should be (LocalDate.of(2013, 7, 24))
+  }
+
+  test ("fourth wednesday of august 2013") {
+    pending
+    Meetup(8, 2013).fourth(Meetup.Wed) should be (LocalDate.of(2013, 8, 28))
+  }
+
+  test ("fourth thursday of september 2013") {
+    pending
+    Meetup(9, 2013).fourth(Meetup.Thu) should be (LocalDate.of(2013, 9, 26))
   }
 
-  test ("fourth respects month") {
+  test ("fourth thursday of october 2013") {
     pending
-    Meetup(4, 2013).fourth(Meetup.Mon) should be (new GregorianCalendar(2013, 3, 22))
+    Meetup(10, 2013).fourth(Meetup.Thu) should be (LocalDate.of(2013, 10, 24))
   }
 
-  test ("fourth respects year") {
+  test ("fourth friday of november 2013") {
     pending
-    Meetup(5, 2016).fourth(Meetup.Mon) should be (new GregorianCalendar(2016, 4, 23))
+    Meetup(11, 2013).fourth(Meetup.Fri) should be (LocalDate.of(2013, 11, 22))
   }
 
-  test ("fourth respects weekday") {
+  test ("fourth friday of december 2013") {
     pending
-    Meetup(6, 2013).fourth(Meetup.Tue) should be (new GregorianCalendar(2013, 5, 25))
+    Meetup(12, 2013).fourth(Meetup.Fri) should be (LocalDate.of(2013, 12, 27))
   }
 
-  test ("fourth works on a variety of dates") {
+  test ("fourth saturday of january 2013") {
     pending
-    Meetup(7, 2013).fourth(Meetup.Wed) should be (new GregorianCalendar(2013, 6, 24))
-    Meetup(8, 2013).fourth(Meetup.Wed) should be (new GregorianCalendar(2013, 7, 28))
-    Meetup(9, 2013).fourth(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 26))
-    Meetup(10, 2013).fourth(Meetup.Thu) should be (new GregorianCalendar(2013, 9, 24))
-    Meetup(11, 2013).fourth(Meetup.Fri) should be (new GregorianCalendar(2013, 10, 22))
-    Meetup(12, 2013).fourth(Meetup.Fri) should be (new GregorianCalendar(2013, 11, 27))
-    Meetup(1, 2013).fourth(Meetup.Sat) should be (new GregorianCalendar(2013, 0, 26))
-    Meetup(2, 2013).fourth(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 23))
-    Meetup(3, 2013).fourth(Meetup.Sun) should be (new GregorianCalendar(2013, 2, 24))
-    Meetup(4, 2013).fourth(Meetup.Sun) should be (new GregorianCalendar(2013, 3, 28))
+    Meetup(1, 2013).fourth(Meetup.Sat) should be (LocalDate.of(2013, 1, 26))
+  }
+
+  test ("fourth saturday of february 2013") {
+    pending
+    Meetup(2, 2013).fourth(Meetup.Sat) should be (LocalDate.of(2013, 2, 23))
+  }
+
+  test ("fourth sunday of march 2013") {
+    pending
+    Meetup(3, 2013).fourth(Meetup.Sun) should be (LocalDate.of(2013, 3, 24))
+  }
+
+  test ("fourth sunday of april 2013") {
+    pending
+    Meetup(4, 2013).fourth(Meetup.Sun) should be (LocalDate.of(2013, 4, 28))
   }
 
   test ("last monday of march 2013") {
     pending
-    Meetup(3, 2013).last(Meetup.Mon) should be (new GregorianCalendar(2013, 2, 25))
+    Meetup(3, 2013).last(Meetup.Mon) should be (LocalDate.of(2013, 3, 25))
+  }
+
+  test ("last monday of april 2013") {
+    pending
+    Meetup(4, 2013).last(Meetup.Mon) should be (LocalDate.of(2013, 4, 29))
   }
 
-  test ("last respects month") {
+  test ("last tuesday of may 2013") {
     pending
-    Meetup(4, 2013).last(Meetup.Mon) should be (new GregorianCalendar(2013, 3, 29))
+    Meetup(5, 2013).last(Meetup.Tue) should be (LocalDate.of(2013, 5, 28))
   }
 
-  test ("last respects year") {
+  test ("last tuesday of june 2013") {
     pending
-    Meetup(6, 2016).last(Meetup.Mon) should be (new GregorianCalendar(2016, 5, 27))
+    Meetup(6, 2013).last(Meetup.Tue) should be (LocalDate.of(2013, 6, 25))
   }
 
-  test ("last respects weekday") {
+  test ("last wednesday of july 2013") {
     pending
-    Meetup(5, 2013).last(Meetup.Tue) should be (new GregorianCalendar(2013, 4, 28))
+    Meetup(7, 2013).last(Meetup.Wed) should be (LocalDate.of(2013, 7, 31))
   }
 
-  test ("works on a leap year") {
+  test ("last wednesday of august 2013") {
     pending
-    Meetup(2, 2016).last(Meetup.Sun) should be (new GregorianCalendar(2016, 1, 28))
-    Meetup(2, 2016).last(Meetup.Mon) should be (new GregorianCalendar(2016, 1, 29))
+    Meetup(8, 2013).last(Meetup.Wed) should be (LocalDate.of(2013, 8, 28))
   }
 
-  test ("last works on a variety of dates") {
+  test ("last thursday of september 2013") {
     pending
-    Meetup(7, 2013).last(Meetup.Wed) should be (new GregorianCalendar(2013, 6, 31))
-    Meetup(8, 2013).last(Meetup.Wed) should be (new GregorianCalendar(2013, 7, 28))
-    Meetup(9, 2013).last(Meetup.Thu) should be (new GregorianCalendar(2013, 8, 26))
-    Meetup(10, 2013).last(Meetup.Thu) should be (new GregorianCalendar(2013, 9, 31))
-    Meetup(11, 2013).last(Meetup.Fri) should be (new GregorianCalendar(2013, 10, 29))
-    Meetup(12, 2013).last(Meetup.Fri) should be (new GregorianCalendar(2013, 11, 27))
-    Meetup(1, 2013).last(Meetup.Sat) should be (new GregorianCalendar(2013, 0, 26))
-    Meetup(2, 2013).last(Meetup.Sat) should be (new GregorianCalendar(2013, 1, 23))
-    Meetup(3, 2013).last(Meetup.Sun) should be (new GregorianCalendar(2013, 2, 31))
-    Meetup(4, 2013).last(Meetup.Sun) should be (new GregorianCalendar(2013, 3, 28))
+    Meetup(9, 2013).last(Meetup.Thu) should be (LocalDate.of(2013, 9, 26))
+  }
+
+  test ("last thursday of october 2013") {
+    pending
+    Meetup(10, 2013).last(Meetup.Thu) should be (LocalDate.of(2013, 10, 31))
+  }
+
+  test ("last friday of november 2013") {
+    pending
+    Meetup(11, 2013).last(Meetup.Fri) should be (LocalDate.of(2013, 11, 29))
+  }
+
+  test ("last friday of december 2013") {
+    pending
+    Meetup(12, 2013).last(Meetup.Fri) should be (LocalDate.of(2013, 12, 27))
+  }
+
+  test ("last saturday of january 2013") {
+    pending
+    Meetup(1, 2013).last(Meetup.Sat) should be (LocalDate.of(2013, 1, 26))
+  }
+
+  test ("last saturday of february 2013") {
+    pending
+    Meetup(2, 2013).last(Meetup.Sat) should be (LocalDate.of(2013, 2, 23))
+  }
+
+  test ("last sunday of march 2013") {
+    pending
+    Meetup(3, 2013).last(Meetup.Sun) should be (LocalDate.of(2013, 3, 31))
+  }
+
+  test ("last sunday of april 2013") {
+    pending
+    Meetup(4, 2013).last(Meetup.Sun) should be (LocalDate.of(2013, 4, 28))
   }
 }
+