trackler 2.2.0.4 → 2.2.0.5

data/tracks/kotlin/exercises/forth/src/test/kotlin/ForthEvaluatorTest.kt

@@ -0,0 +1,352 @@
+import org.junit.Before
+import org.junit.Ignore
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.2.0
+ */
+class ForthEvaluatorTest {
+
+    @Rule
+    @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    private lateinit var forthEvaluator: ForthEvaluator
+
+    @Before
+    fun setUp() {
+        forthEvaluator = ForthEvaluator()
+    }
+
+    @Test
+    fun testEmptyProgramResultsInEmptyStack() {
+        assertEquals(
+                emptyList(),
+                forthEvaluator.evaluateProgram(emptyList()))
+    }
+
+    @Ignore
+    @Test
+    fun testNumbersAreJustPushedOntoTheStack() {
+        assertEquals(
+                listOf(1, 2, 3, 4, 5),
+                forthEvaluator.evaluateProgram(listOf("1 2 3 4 5")))
+    }
+
+    @Ignore
+    @Test
+    fun testTwoNumbersCanBeAdded() {
+        assertEquals(
+                listOf(3),
+                forthEvaluator.evaluateProgram(listOf("1 2 +")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfAdditionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Addition requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("+"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfAdditionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Addition requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 +"))
+    }
+
+    @Ignore
+    @Test
+    fun testTwoNumbersCanBeSubtracted() {
+        assertEquals(
+                listOf(-1),
+                forthEvaluator.evaluateProgram(listOf("3 4 -")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfSubtractionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Subtraction requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("-"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfSubtractionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Subtraction requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 -"))
+    }
+
+    @Ignore
+    @Test
+    fun testTwoNumbersCanBeMultiplied() {
+        assertEquals(
+                listOf(8),
+                forthEvaluator.evaluateProgram(listOf("2 4 *")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfMultiplicationAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Multiplication requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("*"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfMultiplicationAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Multiplication requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 *"))
+    }
+
+    @Ignore
+    @Test
+    fun testTwoNumbersCanBeDivided() {
+        assertEquals(
+                listOf(4),
+                forthEvaluator.evaluateProgram(listOf("12 3 /")))
+    }
+
+    @Ignore
+    @Test
+    fun testThatIntegerDivisionIsUsed() {
+        assertEquals(
+                listOf(2),
+                forthEvaluator.evaluateProgram(listOf("8 3 /")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfDividingByZero() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Division by 0 is not allowed")
+
+        forthEvaluator.evaluateProgram(listOf("4 0 /"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfDivisionAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Division requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("/"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfDivisionAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Division requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 /"))
+    }
+
+    @Ignore
+    @Test
+    fun testCombinedAdditionAndSubtraction() {
+        assertEquals(
+                listOf(-1),
+                forthEvaluator.evaluateProgram(listOf("1 2 + 4 -")))
+    }
+
+    @Ignore
+    @Test
+    fun testCombinedMultiplicationAndDivision() {
+        assertEquals(
+                listOf(2),
+                forthEvaluator.evaluateProgram(listOf("2 4 * 3 /")))
+    }
+
+    @Ignore
+    @Test
+    fun testDupCopiesTheTopValueOnTheStack() {
+        assertEquals(
+                listOf(1, 1),
+                forthEvaluator.evaluateProgram(listOf("1 DUP")))
+    }
+
+    @Ignore
+    @Test
+    fun testDupParsingIsCaseInsensitive() {
+        assertEquals(
+                listOf(1, 2, 2),
+                forthEvaluator.evaluateProgram(listOf("1 2 Dup")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfDuplicatingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Duplicating requires that the stack contain at least 1 value")
+
+        forthEvaluator.evaluateProgram(listOf("dup"))
+    }
+
+    @Ignore
+    @Test
+    fun testDropRemovesTheTopValueOnTheStackIfItIsTheOnlyOne() {
+        assertEquals(
+                emptyList(),
+                forthEvaluator.evaluateProgram(listOf("1 drop")))
+    }
+
+    @Ignore
+    @Test
+    fun testDropRemovesTheTopValueOnTheStackIfItIsNotTheOnlyOne() {
+        assertEquals(
+                listOf(1),
+                forthEvaluator.evaluateProgram(listOf("1 2 drop")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfDroppingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Dropping requires that the stack contain at least 1 value")
+
+        forthEvaluator.evaluateProgram(listOf("drop"))
+    }
+
+    @Ignore
+    @Test
+    fun testSwapSwapsTheTopTwosValueOnTheStackIfTheyAreTheOnlyOnes() {
+        assertEquals(
+                listOf(2, 1),
+                forthEvaluator.evaluateProgram(listOf("1 2 swap")))
+    }
+
+    @Ignore
+    @Test
+    fun testSwapSwapsTheTopTwosValueOnTheStackIfTheyAreNotTheOnlyOnes() {
+        assertEquals(
+                listOf(1, 3, 2),
+                forthEvaluator.evaluateProgram(listOf("1 2 3 swap")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfSwappingAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Swapping requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("swap"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfSwappingAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Swapping requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 swap"))
+    }
+
+    @Ignore
+    @Test
+    fun testOverCopiesTheSecondElementIfThereAreOnlyTwo() {
+        assertEquals(
+                listOf(1, 2, 1),
+                forthEvaluator.evaluateProgram(listOf("1 2 over")))
+    }
+
+    @Ignore
+    @Test
+    fun testOverCopiesTheSecondElementIfThereAreMoreThanTwo() {
+        assertEquals(
+                listOf(1, 2, 3, 2),
+                forthEvaluator.evaluateProgram(listOf("1 2 3 over")))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfOveringAttemptedWithNothingOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Overing requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("over"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfOveringAttemptedWithOneNumberOnTheStack() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Overing requires that the stack contain at least 2 values")
+
+        forthEvaluator.evaluateProgram(listOf("1 over"))
+    }
+
+    @Ignore
+    @Test
+    fun testUserDefinedOperatorsCanConsistOfBuiltInOperators() {
+        assertEquals(
+                listOf(1, 1, 1),
+                forthEvaluator.evaluateProgram(listOf(": dup-twice dup dup ;", "1 dup-twice")))
+    }
+
+    @Ignore
+    @Test
+    fun testUserDefinedOperatorsAreEvaluatedInTheCorrectOrder() {
+        assertEquals(
+                listOf(1, 2, 3),
+                forthEvaluator.evaluateProgram(listOf(": countup 1 2 3 ;", "countup")))
+    }
+
+    @Ignore
+    @Test
+    fun testCanRedefineAUserDefinedOperator() {
+        assertEquals(
+                listOf(1, 1, 1),
+                forthEvaluator.evaluateProgram(listOf(": foo dup ;", ": foo dup dup ;", "1 foo")))
+    }
+
+    @Ignore
+    @Test
+    fun testCanOverrideBuiltInWordOperators() {
+        assertEquals(
+                listOf(1, 1),
+                forthEvaluator.evaluateProgram(listOf(": swap dup ;", "1 swap")))
+    }
+
+    @Ignore
+    @Test
+    fun testCanOverrideBuiltInArithmeticOperators() {
+        assertEquals(
+                listOf(12),
+                forthEvaluator.evaluateProgram(listOf(": + * ;", "3 4 +")))
+    }
+
+    @Ignore
+    @Test
+    fun testCannotRedefineNumbers() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Cannot redefine numbers")
+
+        forthEvaluator.evaluateProgram(listOf(": 1 2 ;"))
+    }
+
+    @Ignore
+    @Test
+    fun testErrorIfEvaluatingAnUndefinedOperator() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("No definition available for operator \"foo\"")
+
+        forthEvaluator.evaluateProgram(listOf("foo"))
+    }
+
+}

data/tracks/kotlin/exercises/meetup/README.md

@@ -0,0 +1,33 @@
+# Meetup
+
+Calculate the date of meetups.
+
+Typically meetups happen on the same day of the week.  In this exercise, you will take
+a description of a meetup date, and return the actual meetup date.
+
+Examples of general descriptions are:
+
+- the first Monday of January 2017
+- the third Tuesday of January 2017
+- the Wednesteenth of January 2017
+- the last Thursday of January 2017
+
+Note that "Monteenth", "Tuesteenth", etc are all made up words. There
+was a meetup whose members realized that there are exactly 7 numbered days in a month that
+end in '-teenth'. Therefore, one is guaranteed that each day of the week
+(Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
+in every month.
+
+Given examples of a meetup dates, each containing a month, day, year, and descriptor 
+(first, second, teenth, etc), calculate the date of the actual meetup.
+For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
+ 
+
+
+
+## Source
+
+Jeremy Hinegardner mentioned a Boulder meetup that happens on the Wednesteenth of every month [https://twitter.com/copiousfreetime](https://twitter.com/copiousfreetime)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/kotlin/exercises/meetup/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/kotlin/exercises/meetup/src/example/kotlin/Meetup.kt

@@ -0,0 +1,45 @@
+import java.time.DayOfWeek
+import java.time.LocalDate
+
+class Meetup(monthOfYear: Int, year: Int) {
+
+    private val startOfMonth: LocalDate = LocalDate.of(year, monthOfYear, 1)
+
+    fun day(dayOfWeek: DayOfWeek, schedule: MeetupSchedule): LocalDate {
+        var result = cycleToNext(dayOfWeek, startOfMonth)
+
+        @Suppress("NON_EXHAUSTIVE_WHEN")
+        when (schedule) {
+            MeetupSchedule.SECOND -> result = result.plusWeeks(1)
+            MeetupSchedule.THIRD  -> result = result.plusWeeks(2)
+            MeetupSchedule.FOURTH -> result = result.plusWeeks(3)
+            MeetupSchedule.LAST   -> result = cycleToPrev(dayOfWeek, startOfMonth.plusMonths(1).minusDays(1))
+            MeetupSchedule.TEENTH -> {
+                while (result.dayOfMonth < 13) result = result.plusWeeks(1)
+            }
+        }
+
+        return result
+    }
+
+    private fun cycleToPrev(dayOfWeek: DayOfWeek, current: LocalDate): LocalDate {
+        var result = current
+
+        while (result.dayOfWeek != dayOfWeek) {
+            result = result.minusDays(1)
+        }
+
+        return result
+    }
+
+    private fun cycleToNext(dayOfWeek: DayOfWeek, current: LocalDate): LocalDate {
+        var result = current
+
+        while (result.dayOfWeek != dayOfWeek) {
+            result = result.plusDays(1)
+        }
+
+        return result
+    }
+
+}

data/tracks/kotlin/exercises/meetup/src/example/kotlin/MeetupSchedule.kt

@@ -0,0 +1 @@
+../../main/kotlin/MeetupSchedule.kt

data/tracks/kotlin/exercises/meetup/src/main/kotlin/MeetupSchedule.kt

@@ -0,0 +1,5 @@
+enum class MeetupSchedule {
+
+    FIRST, SECOND, THIRD, FOURTH, LAST, TEENTH
+
+}