trackler 2.1.0.22 → 2.1.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbced8992b854c512c715f27a6bc9901d2970782
-  data.tar.gz: ce15baa96319c1f0824907c901ad918fa8927a4f
+  metadata.gz: a5a1f4bc1094d7cab6ba4f22a20e28874665bbb9
+  data.tar.gz: 66cd048370d77f78ffdfef48b573fe302129e99a
 SHA512:
-  metadata.gz: d477788c1072990660270c29a37920b0eabafb79b08cdefc7e514ad5e24e42e56e84f4bc6e87864ee27b8617244553fdac941a17337a2cafb7c2c8fd3136f6a9
-  data.tar.gz: 934f4fa9ed27cddbf3077ee3b6ccfc18a65f322ccd1cce7656aeb94a07f9def5c3d96533e2189c8153f2d9763b2f07654dd7f2272c7bd800eacfc844112e68e2
+  metadata.gz: d0632cd9d571b3d6f1a604b748380d1b6ba4b3f6501970f4bac7c84361a0ef0ede21d9e0b118968e9daa04dde82fd11619a6edf9cee61e18f0234ea691b9935e
+  data.tar.gz: 3cd5cc5489046c92b192e7955f0c0a18be47eecf3b3c88735a5ba483fc2675027d52f2fca726f51253cdec7fe3c30951e6a10e63baadb47c0d11caef7117db45

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.1.0.22"
+  VERSION = "2.1.0.23"
 end

data/tracks/elm/exercises/accumulate/Tests.elm

@@ -16,7 +16,7 @@ square x =
 tests : Test
 tests =
     describe "Accumulate"
-        [ test "[]] Accumulate" <|
+        [ test "[] Accumulate" <|
             \() -> Expect.equal [] (accumulate square [])
         , test "square Accumulate" <|
             \() -> Expect.equal [ 1, 4, 9 ] (accumulate square [ 1, 2, 3 ])

data/tracks/elm/exercises/pangram/Tests.elm

@@ -22,6 +22,10 @@ tests =
             \() ->
                 Expect.equal False
                     (isPangram "a quick movement of the enemy will jeopardize five gunboats")
+        , test "missing character 'z'" <|
+            \() ->
+                Expect.equal False
+                    (isPangram "a quick movement of the enemy will jeopardixe five gunboats")
         , test "another missing character 'x'" <|
             \() ->
                 Expect.equal False

data/tracks/kotlin/bin/journey-test.sh

@@ -214,6 +214,8 @@ solve_all_exercises() {
     cp -R -H ${track_root}/exercises/${exercise}/src/example/${TRACK}/* ${exercism_exercises_dir}/${TRACK}/${exercise}/src/main/${TRACK}/
 
     pushd ${exercism_exercises_dir}/${TRACK}/${exercise}
+    # Check that tests compile before we strip @Ignore annotations
+    gradle compileTestJava
     # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
     for testfile in `find . -name "*Test.${TRACK_SRC_EXT}"`; do
       sed 's/@Ignore//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"

data/tracks/kotlin/config.json

@@ -228,11 +228,30 @@
       "slug": "change",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "clock",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "triangle",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "sum-of-multiples",
+      "topics": [
+        "Ranges",
+        "Collections",
+        "Lambdas"
+      ]
+    },
+    {
+      "difficulty": 1,
+      "slug": "all-your-base",
+      "topics": []
+    },
     {
       "difficulty": 2,
       "slug": "bank-account",

data/tracks/kotlin/exercises/all-your-base/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/all-your-base/src/example/kotlin/BaseConverter.kt

@@ -0,0 +1,59 @@
+class BaseConverter(originalBase: Int, originalDigits: IntArray) {
+
+    companion object {
+        private val MINIMUM_VALID_BASE = 2
+        private val INVALID_BASE_ERROR_MESSAGE = "Bases must be at least 2."
+    }
+
+    private val numeral: Int
+
+    init {
+        require(originalBase >= MINIMUM_VALID_BASE) { INVALID_BASE_ERROR_MESSAGE }
+        require(originalDigits.isNotEmpty()) { "You must supply at least one digit." }
+        require(originalDigits.size == 1 || originalDigits[0] != 0) { "Digits may not contain leading zeros." }
+        require(originalDigits.min()!! >= 0) { "Digits may not be negative." }
+        require(originalDigits.max()!! < originalBase) { "All digits must be strictly less than the base." }
+
+        this.numeral = computeNumeral(originalBase, originalDigits)
+    }
+
+    fun convertToBase(newBase: Int): IntArray {
+        require(newBase >= MINIMUM_VALID_BASE) { INVALID_BASE_ERROR_MESSAGE }
+
+        val largestExponent = computeLargestExponentForBase(newBase)
+        val result = IntArray(largestExponent + 1)
+        var remainder = numeral
+
+        for (currentExponent in largestExponent downTo 0) {
+            val coefficient = Math.floor(remainder / Math.pow(newBase.toDouble(), currentExponent.toDouble())).toInt()
+
+            result[largestExponent - currentExponent] = coefficient
+
+            remainder -= (coefficient * Math.pow(newBase.toDouble(), currentExponent.toDouble())).toInt()
+        }
+
+        return result
+    }
+
+    private fun computeNumeral(originalBase: Int, originalDigits: IntArray): Int {
+        val largestExponent = originalDigits.size - 1
+
+        val result = (largestExponent downTo 0).sumBy { exponent ->
+            (originalDigits[largestExponent - exponent]
+                * Math.pow(originalBase.toDouble(), exponent.toDouble())).toInt()
+        }
+
+        return result
+    }
+
+    private fun computeLargestExponentForBase(newBase: Int): Int {
+        var result = 0
+
+        while (Math.pow(newBase.toDouble(), (result + 1).toDouble()) < numeral) {
+            result += 1
+        }
+
+        return result
+    }
+
+}

data/tracks/kotlin/exercises/all-your-base/src/test/kotlin/BaseConverterTest.kt

@@ -0,0 +1,250 @@
+import org.junit.Assert.assertArrayEquals
+import org.junit.Ignore
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import java.util.*
+
+/*
+ * version: 1.0.0
+ */
+class BaseConverterTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    @Test
+    fun testSingleBitOneToDecimal() {
+        val baseConverter = BaseConverter(2, intArrayOf(1))
+
+        val expectedDigits = intArrayOf(1)
+        val actualDigits = baseConverter.convertToBase(10)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testBinaryToSingleDecimal() {
+        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1))
+
+        val expectedDigits = intArrayOf(5)
+        val actualDigits = baseConverter.convertToBase(10)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testSingleDecimalToBinary() {
+        val baseConverter = BaseConverter(10, intArrayOf(5))
+
+        val expectedDigits = intArrayOf(1, 0, 1)
+        val actualDigits = baseConverter.convertToBase(2)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testBinaryToMultipleDecimal() {
+        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
+
+        val expectedDigits = intArrayOf(4, 2)
+        val actualDigits = baseConverter.convertToBase(10)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testDecimalToBinary() {
+        val baseConverter = BaseConverter(10, intArrayOf(4, 2))
+
+        val expectedDigits = intArrayOf(1, 0, 1, 0, 1, 0)
+        val actualDigits = baseConverter.convertToBase(2)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testTrinaryToHexadecimal() {
+        val baseConverter = BaseConverter(3, intArrayOf(1, 1, 2, 0))
+
+        val expectedDigits = intArrayOf(2, 10)
+        val actualDigits = baseConverter.convertToBase(16)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testHexadecimalToTrinary() {
+        val baseConverter = BaseConverter(16, intArrayOf(2, 10))
+
+        val expectedDigits = intArrayOf(1, 1, 2, 0)
+        val actualDigits = baseConverter.convertToBase(3)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun test15BitInteger() {
+        val baseConverter = BaseConverter(97, intArrayOf(3, 46, 60))
+
+        val expectedDigits = intArrayOf(6, 10, 45)
+        val actualDigits = baseConverter.convertToBase(73)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testEmptyDigits() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("You must supply at least one digit.")
+
+        BaseConverter(2, intArrayOf())
+    }
+
+    @Ignore
+    @Test
+    fun testSingleZero() {
+        val baseConverter = BaseConverter(10, intArrayOf(0))
+
+        val expectedDigits = intArrayOf(0)
+        val actualDigits = baseConverter.convertToBase(2)
+
+        assertArrayEquals(
+            "Expected digits: ${Arrays.toString(expectedDigits)} but found digits: ${Arrays.toString(actualDigits)}",
+            expectedDigits,
+            actualDigits)
+    }
+
+    @Ignore
+    @Test
+    fun testMultipleZeros() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Digits may not contain leading zeros.")
+
+        BaseConverter(10, intArrayOf(0, 0, 0))
+    }
+
+    @Ignore
+    @Test
+    fun testLeadingZeros() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Digits may not contain leading zeros.")
+
+        BaseConverter(7, intArrayOf(0, 6, 0))
+    }
+
+    @Ignore
+    @Test
+    fun testNegativeDigit() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Digits may not be negative.")
+
+        BaseConverter(2, intArrayOf(1, -1, 1, 0, 1, 0))
+    }
+
+    @Ignore
+    @Test
+    fun testInvalidPositiveDigit() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("All digits must be strictly less than the base.")
+
+        BaseConverter(2, intArrayOf(1, 2, 1, 0, 1, 0))
+    }
+
+    @Ignore
+    @Test
+    fun testFirstBaseIsOne() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        BaseConverter(1, intArrayOf())
+    }
+
+    @Ignore
+    @Test
+    fun testSecondBaseIsOne() {
+        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
+
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        baseConverter.convertToBase(1)
+    }
+
+    @Ignore
+    @Test
+    fun testFirstBaseIsZero() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        BaseConverter(0, intArrayOf())
+    }
+
+    @Ignore
+    @Test
+    fun testSecondBaseIsZero() {
+        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
+
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        baseConverter.convertToBase(0)
+    }
+
+    @Ignore
+    @Test
+    fun testFirstBaseIsNegative() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        BaseConverter(-2, intArrayOf())
+    }
+
+    @Ignore
+    @Test
+    fun testSecondBaseIsNegative() {
+        val baseConverter = BaseConverter(2, intArrayOf(1))
+
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Bases must be at least 2.")
+
+        baseConverter.convertToBase(-7)
+    }
+
+}

data/tracks/kotlin/exercises/clock/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/clock/src/example/kotlin/Clock.kt

@@ -0,0 +1,40 @@
+data class Clock(private var hours: Int, private var minutes: Int) {
+
+    companion object {
+        private val MINUTES_IN_AN_HOUR = 60
+        private val HOURS_IN_A_DAY = 24
+    }
+
+    init {
+        sanitiseTime()
+    }
+
+    override fun toString(): String {
+        return "${hours.toTimeString()}:${minutes.toTimeString()}"
+    }
+
+    fun add(minutes: Int) {
+        this.minutes += minutes
+        sanitiseTime()
+    }
+
+    private fun sanitiseTime() {
+        while (minutes < 0) {
+            minutes += MINUTES_IN_AN_HOUR
+            hours--
+        }
+
+        while (hours < 0) {
+            hours += HOURS_IN_A_DAY
+        }
+
+        val minutesOverflow = minutes / MINUTES_IN_AN_HOUR
+        minutes %= MINUTES_IN_AN_HOUR
+        hours = (hours + minutesOverflow) % HOURS_IN_A_DAY
+    }
+
+}
+
+private fun Int.toTimeString(): String {
+    return toString().padStart(length = 2, padChar = '0')
+}

data/tracks/kotlin/exercises/clock/src/test/kotlin/ClockAddTest.kt

@@ -0,0 +1,138 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockAddTest {
+
+    @Ignore
+    @Test
+    fun addMinutes() {
+        val clock = Clock(10, 0)
+        clock.add(3)
+        assertEquals("10:03", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addNoMinutes() {
+        val clock = Clock(6, 41)
+        clock.add(0)
+        assertEquals("06:41", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addToNextHour() {
+        val clock = Clock(0, 45)
+        clock.add(40)
+        assertEquals("01:25", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanOneHour() {
+        val clock = Clock(10, 0)
+        clock.add(61)
+        assertEquals("11:01", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanTwoHoursWithCarry() {
+        val clock = Clock(0, 45)
+        clock.add(160)
+        assertEquals("03:25", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addAcrossMidnight() {
+        val clock = Clock(23, 59)
+        clock.add(2)
+        assertEquals("00:01", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanOneDay() {
+        val clock = Clock(5, 32)
+        clock.add(1500)
+        assertEquals("06:32", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun addMoreThanTwoDays() {
+        val clock = Clock(1, 1)
+        clock.add(3500)
+        assertEquals("11:21", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMinutes() {
+        val clock = Clock(10, 3)
+        clock.add(-3)
+        assertEquals("10:00", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractToPreviousHour() {
+        val clock = Clock(10, 3)
+        clock.add(-30)
+        assertEquals("09:33", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanAnHour() {
+        val clock = Clock(10, 3)
+        clock.add(-70)
+        assertEquals("08:53", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractAcrossMidnight() {
+        val clock = Clock(0, 3)
+        clock.add(-4)
+        assertEquals("23:59", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoHours() {
+        val clock = Clock(0, 0)
+        clock.add(-160)
+        assertEquals("21:20", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoHoursWithBorrow() {
+        val clock = Clock(6, 15)
+        clock.add(-160)
+        assertEquals("03:35", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanOneDay() {
+        val clock = Clock(5, 32)
+        clock.add(-1500)
+        assertEquals("04:32", clock.toString())
+    }
+
+    @Ignore
+    @Test
+    fun subtractMoreThanTwoDays() {
+        val clock = Clock(2, 20)
+        clock.add(-3000)
+        assertEquals("00:20", clock.toString())
+    }
+
+}

data/tracks/kotlin/exercises/clock/src/test/kotlin/ClockCreationTest.kt

@@ -0,0 +1,123 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockCreationTest {
+
+    @Test
+    fun canPrintTimeOnTheHour() {
+        assertEquals("08:00", Clock(8, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun canPrintTimeWithMinutes() {
+        assertEquals("11:09", Clock(11, 9).toString())
+    }
+
+    @Ignore
+    @Test
+    fun midnightPrintsAsZero() {
+        assertEquals("00:00", Clock(24, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourRollsOver() {
+        assertEquals("01:00", Clock(25, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourRollsOverContinuously() {
+        assertEquals("04:00", Clock(100, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun sixtyMinutesIsNextHour() {
+        assertEquals("02:00", Clock(1, 60).toString())
+    }
+
+    @Ignore
+    @Test
+    fun minutesRollOver() {
+        assertEquals("02:40", Clock(0, 160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun minutesRollOverContinuously() {
+        assertEquals("04:43", Clock(0, 1723).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOver() {
+        assertEquals("03:40", Clock(25, 160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOverContinuously() {
+        assertEquals("11:01", Clock(201, 3001).toString())
+    }
+
+    @Ignore
+    @Test
+    fun hourAndMinutesRollOverToExactlyMidnight() {
+        assertEquals("00:00", Clock(72, 8640).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHour() {
+        assertEquals("23:15", Clock(-1, 15).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourRollsOver() {
+        assertEquals("23:00", Clock(-25, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourRollsOverContinuously() {
+        assertEquals("05:00", Clock(-91, 0).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutes() {
+        assertEquals("00:20", Clock(1, -40).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutesRollOver() {
+        assertEquals("22:20", Clock(1, -160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeMinutesRollOverContinuously() {
+        assertEquals("16:40", Clock(1, -4820).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourAndMinutesBothRollOver() {
+        assertEquals("20:20", Clock(-25, -160).toString())
+    }
+
+    @Ignore
+    @Test
+    fun negativeHourAndMinutesBothRollOverContinuously() {
+        assertEquals("22:10", Clock(-121, -5810).toString())
+    }
+
+}

data/tracks/kotlin/exercises/clock/src/test/kotlin/ClockEqualTest.kt

@@ -0,0 +1,101 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertNotEquals
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.1
+ */
+class ClockEqualTest {
+
+    @Ignore
+    @Test
+    fun clocksWithSameTimeAreEqual() {
+        assertEquals(Clock(15, 37), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksAMinuteApartAreNotEqual() {
+        assertNotEquals(Clock(15, 36), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksAnHourApartAreNotEqual() {
+        assertNotEquals(Clock(14, 37), Clock(15, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithHourOverflow() {
+        assertEquals(Clock(10, 37), Clock(34, 37))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithHourOverflowBySeveralDays() {
+        assertEquals(Clock(3, 11), Clock(99, 11))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegateHour() {
+        assertEquals(Clock(22, 40), Clock(-2, 40))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHourThatWraps() {
+        assertEquals(Clock(17, 3), Clock(-31, 3))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHourThatWrapsMultipleTimes() {
+        assertEquals(Clock(13, 49), Clock(-83, 49))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithMinuteOverflow() {
+        assertEquals(Clock(0, 1), Clock(0, 1441))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithMinuteOverflowBySeveralDays() {
+        assertEquals(Clock(2, 2), Clock(2, 4322))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutes() {
+        assertEquals(Clock(2, 40), Clock(3, -20))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutesThatWraps() {
+        assertEquals(Clock(4, 10), Clock(5, -1490))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeMinutesThatWrapsMultipleTimes() {
+        assertEquals(Clock(6, 15), Clock(6, -4305))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHoursAndMinutes() {
+        assertEquals(Clock(7, 32), Clock(-12, -268))
+    }
+
+    @Ignore
+    @Test
+    fun clocksWithNegativeHoursAndMinutesThatWrap() {
+        assertEquals(Clock(18, 7), Clock(-54, -11513))
+    }
+
+}

data/tracks/kotlin/exercises/settings.gradle

@@ -2,11 +2,13 @@ include 'hello-world'
 include 'accumulate'
 include 'acronym'
 include 'allergies'
+include 'all-your-base'
 include 'anagram'
 include 'atbash-cipher'
 include 'beer-song'
 include 'binary'
 include 'bob'
+include 'clock'
 include 'difference-of-squares'
 include 'etl'
 include 'flatten-array'
@@ -43,3 +45,4 @@ include 'change'
 include 'binary-search'
 include 'triangle'
 include 'bank-account'
+include 'sum-of-multiples'

data/tracks/kotlin/exercises/sum-of-multiples/build.gradle

@@ -0,0 +1,29 @@
+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/sum-of-multiples/src/example/kotlin/SumOfMultiples.kt

@@ -0,0 +1,7 @@
+object SumOfMultiples {
+
+    fun sum(factors: Set<Int>, limit: Int): Int =
+            (1 until limit).filter { x -> factors.any { y -> x.isMultipleOf(y) } }.sum()
+}
+
+fun Int.isMultipleOf(y: Int) = this % y == 0

data/tracks/kotlin/exercises/sum-of-multiples/src/test/kotlin/SumOfMultiplesTest.kt

@@ -0,0 +1,84 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+class SumOfMultiplesTest {
+
+    @Test
+    fun `multiples of 3 or 5 up to 1`() {
+        assertEquals(0, SumOfMultiples.sum(setOf(3, 5), 1))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 3 or 5 up to 4`() {
+        assertEquals(3, SumOfMultiples.sum(setOf(3, 5), 4))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 3 or 5 up to 10`() {
+        assertEquals(23, SumOfMultiples.sum(setOf(3, 5), 10))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 3 or 5 up to 20`() {
+        assertEquals(78, SumOfMultiples.sum(setOf(3, 5), 20))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 3 or 5 up to 100`() {
+        assertEquals(2318, SumOfMultiples.sum(setOf(3, 5), 100))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 3 or 5 up to 1000`() {
+        assertEquals(233_168, SumOfMultiples.sum(setOf(3, 5), 1000))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 7, 13 or 17 up to 20`() {
+        assertEquals(51, SumOfMultiples.sum(setOf(7, 13, 17), 20))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 4 or 6 up to 15`() {
+        assertEquals(30, SumOfMultiples.sum(setOf(4, 6), 15))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 5, 6 or 8 up to 150`() {
+        assertEquals(4419, SumOfMultiples.sum(setOf(5, 6, 8), 150))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 5 or 25 up to 51`() {
+        assertEquals(275, SumOfMultiples.sum(setOf(5, 25), 51))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 43 or 47 up to 10000`() {
+        assertEquals(2_203_160, SumOfMultiples.sum(setOf(43, 47), 10_000))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of 1 up to 100`() {
+        assertEquals(4950, SumOfMultiples.sum(setOf(1), 100))
+    }
+
+    @Test
+    @Ignore
+    fun `multiples of an empty set up to 10000`() {
+        assertEquals(0, SumOfMultiples.sum(emptySet(), 10_000))
+    }
+
+}

data/tracks/python/exercises/grade-school/grade_school_test.py

@@ -45,8 +45,8 @@ class SchoolTest(unittest.TestCase):
         students = [(3, ("Kyle", )), (4, ("Christopher", "Jennifer", )),
                     (6, ("Kareem", ))]
 
-        for grade, students_in_grade in students:
-            for student in students_in_grade:
+        for grade, students_in_grade in students[::-1]:
+            for student in students_in_grade[::-1]:
                 self.school.add(student, grade)
 
         result = self.school.sort()

data/tracks/vimscript/config.json

@@ -2,7 +2,7 @@
   "slug": "vimscript",
   "language": "Vim script",
   "repository": "https://github.com/exercism/xvimscript",
-  "active": false,
+  "active": true,
   "test_pattern": "\\.vader$",
   "exercises": [
     {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.1.0.22
+  version: 2.1.0.23
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-27 00:00:00.000000000 Z
+date: 2017-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -4271,7 +4271,6 @@ files:
 - tracks/java/.git
 - tracks/java/.gitattributes
 - tracks/java/.github/PULL_REQUEST_TEMPLATE.md
-- tracks/java/.github/stale.yml
 - tracks/java/.gitignore
 - tracks/java/.keep
 - tracks/java/.travis.yml
@@ -4921,6 +4920,10 @@ files:
 - tracks/kotlin/exercises/acronym/src/example/kotlin/Acronym.kt
 - tracks/kotlin/exercises/acronym/src/main/kotlin/.keep
 - tracks/kotlin/exercises/acronym/src/test/kotlin/AcronymTest.kt
+- tracks/kotlin/exercises/all-your-base/build.gradle
+- tracks/kotlin/exercises/all-your-base/src/example/kotlin/BaseConverter.kt
+- tracks/kotlin/exercises/all-your-base/src/main/kotlin/.keep
+- tracks/kotlin/exercises/all-your-base/src/test/kotlin/BaseConverterTest.kt
 - tracks/kotlin/exercises/allergies/build.gradle
 - tracks/kotlin/exercises/allergies/src/example/kotlin/Allergen.kt
 - tracks/kotlin/exercises/allergies/src/example/kotlin/Allergies.kt
@@ -4963,6 +4966,12 @@ files:
 - tracks/kotlin/exercises/change/src/example/kotlin/Change.kt
 - tracks/kotlin/exercises/change/src/main/kotlin/.keep
 - tracks/kotlin/exercises/change/src/test/kotlin/ChangeTest.kt
+- tracks/kotlin/exercises/clock/build.gradle
+- tracks/kotlin/exercises/clock/src/example/kotlin/Clock.kt
+- tracks/kotlin/exercises/clock/src/main/kotlin/.keep
+- tracks/kotlin/exercises/clock/src/test/kotlin/ClockAddTest.kt
+- tracks/kotlin/exercises/clock/src/test/kotlin/ClockCreationTest.kt
+- tracks/kotlin/exercises/clock/src/test/kotlin/ClockEqualTest.kt
 - tracks/kotlin/exercises/difference-of-squares/build.gradle
 - tracks/kotlin/exercises/difference-of-squares/src/example/kotlin/Squares.kt
 - tracks/kotlin/exercises/difference-of-squares/src/main/kotlin/.keep
@@ -5094,6 +5103,10 @@ files:
 - tracks/kotlin/exercises/strain/src/example/kotlin/Strain.kt
 - tracks/kotlin/exercises/strain/src/main/kotlin/.keep
 - tracks/kotlin/exercises/strain/src/test/kotlin/StrainTest.kt
+- tracks/kotlin/exercises/sum-of-multiples/build.gradle
+- tracks/kotlin/exercises/sum-of-multiples/src/example/kotlin/SumOfMultiples.kt
+- tracks/kotlin/exercises/sum-of-multiples/src/main/kotlin/.keep
+- tracks/kotlin/exercises/sum-of-multiples/src/test/kotlin/SumOfMultiplesTest.kt
 - tracks/kotlin/exercises/triangle/build.gradle
 - tracks/kotlin/exercises/triangle/src/example/kotlin/Triangle.kt
 - tracks/kotlin/exercises/triangle/src/main/kotlin/.keep

data/tracks/java/.github/stale.yml

@@ -1,8 +0,0 @@
-# Issues or Pull Requests with these labels will never be considered stale
-exemptLabels:
-  - "first-timers only"
-  - "good first patch"
-  - "policy"
-
-# Label to use when marking as stale
-staleLabel: stale