trackler 2.0.6.41 → 2.0.6.42

data/tracks/java/exercises/allergies/src/test/java/AllergiesTest.java

@@ -3,6 +3,7 @@ import org.junit.Ignore;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Collections;
 
 import static org.junit.Assert.assertEquals;
 
@@ -103,7 +104,7 @@ public class AllergiesTest {
     @Test
     public void isAllergicToJustEggs() {
         Allergies allergies = new Allergies(1);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{Allergen.EGGS});
+        List<Allergen> expectedAllergens = Collections.singletonList(Allergen.EGGS);
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -112,7 +113,7 @@ public class AllergiesTest {
     @Test
     public void isAllergicToJustPeanuts() {
         Allergies allergies = new Allergies(2);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{Allergen.PEANUTS});
+        List<Allergen> expectedAllergens = Collections.singletonList(Allergen.PEANUTS);
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -121,7 +122,7 @@ public class AllergiesTest {
     @Test
     public void isAllergicToJustStrawberries() {
         Allergies allergies = new Allergies(8);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{Allergen.STRAWBERRIES});
+        List<Allergen> expectedAllergens = Collections.singletonList(Allergen.STRAWBERRIES);
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -130,10 +131,10 @@ public class AllergiesTest {
     @Test
     public void isAllergicToEggsAndPeanuts() {
         Allergies allergies = new Allergies(3);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{
+        List<Allergen> expectedAllergens = Arrays.asList(
                 Allergen.EGGS,
                 Allergen.PEANUTS
-        });
+        );
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -142,10 +143,10 @@ public class AllergiesTest {
     @Test
     public void isAllergicToEggsAndShellfish() {
         Allergies allergies = new Allergies(5);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{
+        List<Allergen> expectedAllergens = Arrays.asList(
                 Allergen.EGGS,
                 Allergen.SHELLFISH
-        });
+        );
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -154,13 +155,13 @@ public class AllergiesTest {
     @Test
     public void isAllergicToLotsOfStuff() {
         Allergies allergies = new Allergies(248);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{
+        List<Allergen> expectedAllergens = Arrays.asList(
                 Allergen.STRAWBERRIES,
                 Allergen.TOMATOES,
                 Allergen.CHOCOLATE,
                 Allergen.POLLEN,
                 Allergen.CATS
-        });
+        );
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -169,7 +170,7 @@ public class AllergiesTest {
     @Test
     public void isAllergicToEverything() {
         Allergies allergies = new Allergies(255);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{
+        List<Allergen> expectedAllergens = Arrays.asList(
                 Allergen.EGGS,
                 Allergen.PEANUTS,
                 Allergen.SHELLFISH,
@@ -178,7 +179,7 @@ public class AllergiesTest {
                 Allergen.CHOCOLATE,
                 Allergen.POLLEN,
                 Allergen.CATS
-        });
+        );
 
         assertEquals(expectedAllergens, allergies.getList());
     }
@@ -187,7 +188,7 @@ public class AllergiesTest {
     @Test
     public void ignoreNonAllergenScoreParts() {
         Allergies allergies = new Allergies(509);
-        List<Allergen> expectedAllergens = Arrays.asList(new Allergen[]{
+        List<Allergen> expectedAllergens = Arrays.asList(
                 Allergen.EGGS,
                 Allergen.SHELLFISH,
                 Allergen.STRAWBERRIES,
@@ -195,7 +196,7 @@ public class AllergiesTest {
                 Allergen.CHOCOLATE,
                 Allergen.POLLEN,
                 Allergen.CATS
-        });
+        );
 
         assertEquals(expectedAllergens, allergies.getList());
     }

data/tracks/java/exercises/hamming/src/test/java/HammingTest.java

@@ -19,13 +19,13 @@ public class HammingTest {
 
     @Ignore
     @Test
-    public void testCompleteHammingDistanceOfForSingleNucleotideStrand() {
+    public void testHammingDistanceForSingleNucleotideStrand() {
         assertThat(Hamming.compute("A", "G"), is(1));
     }
 
     @Ignore
     @Test
-    public void testCompleteHammingDistanceForSmallStrand() {
+    public void testHammingDistanceForSmallStrand() {
         assertThat(Hamming.compute("AG", "CT"), is(2)); 
     }
 

data/tracks/java/exercises/nth-prime/src/test/java/PrimeTest.java

@@ -1,11 +1,16 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 
 public class PrimeTest {
 
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
     public void testFirstPrime() {
         assertThat(Prime.nth(1), is(2));
@@ -30,8 +35,10 @@ public class PrimeTest {
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testUndefinedPrime() {
+        thrown.expect(IllegalArgumentException.class);
         Prime.nth(0);
     }
+    
 }

data/tracks/java/exercises/nucleotide-count/src/test/java/NucleotideTest.java

@@ -1,5 +1,7 @@
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import java.util.Map;
 
@@ -8,8 +10,11 @@ import static org.junit.Assert.*;
 
 public class NucleotideTest {
 
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
-    public void testEmptyDnaStringHasNoAdenosine() {
+    public void testEmptyDnaStringHasNoAdenine() {
         DNA dna = new DNA("");
         assertThat(dna.count('A'), is(0));
     }
@@ -30,14 +35,14 @@ public class NucleotideTest {
 
     @Ignore
     @Test
-    public void testRepetitiveCytidineGetsCounted() {
+    public void testRepetitiveCytosineGetsCounted() {
         DNA dna = new DNA("CCCCC");
         assertThat(dna.count('C'), is(5));
     }
 
     @Ignore
     @Test
-    public void testRepetitiveSequenceWithOnlyGuanosine() {
+    public void testRepetitiveSequenceWithOnlyGuanine() {
         DNA dna = new DNA("GGGGGGGG");
         Map<Character, Integer> counts = dna.nucleotideCounts();
         assertThat(counts.size(), is(4));
@@ -51,7 +56,7 @@ public class NucleotideTest {
 
     @Ignore
     @Test
-    public void testCountsOnlyThymidine() {
+    public void testCountsOnlyThymine() {
         DNA dna = new DNA("GGGGGTAACCCGG");
         assertThat(dna.count('T'), is(1));
     }
@@ -66,7 +71,7 @@ public class NucleotideTest {
 
     @Ignore
     @Test
-    public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
+    public void testDnaCountsDoNotChangeAfterCountingAdenine() {
         DNA dna = new DNA("GATTACA");
         dna.count('A');
         Map<Character, Integer> counts = dna.nucleotideCounts();
@@ -80,8 +85,9 @@ public class NucleotideTest {
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testValidatesNucleotides() {
+        thrown.expect(IllegalArgumentException.class);
         DNA dna = new DNA("GACT");
         dna.count('X');
     }

data/tracks/java/exercises/pascals-triangle/src/test/java/PascalsTriangleTest.java

@@ -1,12 +1,17 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
 public class PascalsTriangleTest {
 
-
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
     public void testTriangleWithFourRows() {
         int[][] expectedOutput = new int[][]{
@@ -72,8 +77,9 @@ public class PascalsTriangleTest {
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testValidatesNotNegativeRows() {
+        thrown.expect(IllegalArgumentException.class);
         PascalsTriangle.computeTriangle(-1);
     }
 }

data/tracks/java/exercises/series/src/test/java/SeriesTest.java

@@ -1,15 +1,20 @@
-
 import java.util.Arrays;
 import java.util.List;
+
 import org.junit.Test;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
-import org.junit.Ignore;
 
 public class SeriesTest {
-
+    
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
     public void hasDigitsShort() {
         Series sut = new Series("01234");
@@ -146,9 +151,10 @@ public class SeriesTest {
         assertEquals(expected, actual);
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     @Ignore
     public void throwsAnErrorIfNotEnoughDigitsToSlice() {
+        thrown.expect(IllegalArgumentException.class);
         new Series("01032987583").slices(12);
     }
 }

data/tracks/java/exercises/simple-linked-list/src/test/java/SimpleLinkedListTest.java

@@ -1,5 +1,7 @@
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import java.util.NoSuchElementException;
 
@@ -8,7 +10,9 @@ import static org.junit.Assert.*;
 
 public class SimpleLinkedListTest {
 
-
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+    
     @Test
     public void aNewListIsEmpty() {
         SimpleLinkedList list = new SimpleLinkedList();
@@ -24,8 +28,9 @@ public class SimpleLinkedListTest {
     }
 
     @Ignore
-    @Test(expected = NoSuchElementException.class)
+    @Test
     public void popOnEmptyListWillThrow() {
+        thrown.expect(NoSuchElementException.class);
         SimpleLinkedList list = new SimpleLinkedList();
         list.pop();
     }

data/tracks/java/exercises/triangle/src/test/java/TriangleTest.java

@@ -1,13 +1,17 @@
 import org.junit.Test;
 import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
 public class TriangleTest {
 
+    @Rule
+    public final ExpectedException thrown = ExpectedException.none();
 
     @Test
-    public void equilateralTriangleHaveEqualSides() throws Exception {
+    public void equilateralTriangleHaveEqualSides() throws TriangleException {
         Triangle triangle = new Triangle(2, 2, 2);
 
         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
@@ -15,7 +19,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void largerEquilateralTrianglesAlsoHaveEqualSides() throws Exception {
+    public void largerEquilateralTrianglesAlsoHaveEqualSides() throws TriangleException {
         Triangle triangle = new Triangle(10, 10, 10);
 
         assertEquals(TriangleKind.EQUILATERAL, triangle.getKind());
@@ -23,7 +27,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void isoscelesTrianglesHaveLastTwoSidesEqual() throws Exception {
+    public void isoscelesTrianglesHaveLastTwoSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(3, 4, 4);
 
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
@@ -31,7 +35,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void isoscelesTrianglesHaveFirstAndLastSidesEqual() throws Exception {
+    public void isoscelesTrianglesHaveFirstAndLastSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(4, 3, 4);
 
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
@@ -39,7 +43,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void isoscelesTrianglesHaveTwoFirstSidesEqual() throws Exception {
+    public void isoscelesTrianglesHaveTwoFirstSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(4, 4, 3);
 
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
@@ -47,7 +51,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void isoscelesTrianglesHaveInFactExactlyTwoSidesEqual() throws Exception {
+    public void isoscelesTrianglesHaveInFactExactlyTwoSidesEqual() throws TriangleException {
         Triangle triangle = new Triangle(10, 10, 2);
 
         assertEquals(TriangleKind.ISOSCELES, triangle.getKind());
@@ -55,7 +59,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void scaleneTrianglesHaveNoEqualSides() throws Exception {
+    public void scaleneTrianglesHaveNoEqualSides() throws TriangleException {
         Triangle triangle = new Triangle(3, 4, 5);
 
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
@@ -63,7 +67,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void scaleneTrianglesHaveNoEqualSidesAtLargerScaleEither() throws Exception {
+    public void scaleneTrianglesHaveNoEqualSidesAtLargerScaleEither() throws TriangleException {
         Triangle triangle = new Triangle(10, 11, 12);
 
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
@@ -71,7 +75,7 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void scaleneTrianglesHaveNoEqualSidesInDescendingOrderEither() throws Exception {
+    public void scaleneTrianglesHaveNoEqualSidesInDescendingOrderEither() throws TriangleException {
         Triangle triangle = new Triangle(5, 4, 2);
 
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
@@ -79,39 +83,44 @@ public class TriangleTest {
 
     @Ignore
     @Test
-    public void verySmallTrianglesAreLegal() throws Exception {
+    public void verySmallTrianglesAreLegal() throws TriangleException {
         Triangle triangle = new Triangle(0.4, 0.6, 0.3);
 
         assertEquals(TriangleKind.SCALENE, triangle.getKind());
     }
 
     @Ignore
-    @Test(expected = TriangleException.class)
-    public void trianglesWithNoSizeAreIllegal() throws Exception {
+    @Test
+    public void trianglesWithNoSizeAreIllegal() throws TriangleException {
+        thrown.expect(TriangleException.class);
         new Triangle(0, 0, 0);
     }
 
     @Ignore
-    @Test(expected = TriangleException.class)
-    public void trianglesWithNegativeSidesAreIllegal() throws Exception {
+    @Test
+    public void trianglesWithNegativeSidesAreIllegal() throws TriangleException {
+        thrown.expect(TriangleException.class);
         new Triangle(3, 4, -5);
     }
 
     @Ignore
-    @Test(expected = TriangleException.class)
-    public void trianglesViolatingTriangleInequalityAreIllegal() throws Exception {
+    @Test
+    public void trianglesViolatingTriangleInequalityAreIllegal() throws TriangleException {
+        thrown.expect(TriangleException.class);
         new Triangle(1, 1, 3);
     }
 
     @Ignore
-    @Test(expected = TriangleException.class)
-    public void trianglesViolatingTriangleInequalityAreIllegal2() throws Exception {
+    @Test
+    public void trianglesViolatingTriangleInequalityAreIllegal2() throws TriangleException {
+        thrown.expect(TriangleException.class);
         new Triangle(2, 4, 2);
     }
 
     @Ignore
-    @Test(expected = TriangleException.class)
-    public void trianglesViolatingTriangleInequalityAreIllegal3() throws Exception {
+    @Test
+    public void trianglesViolatingTriangleInequalityAreIllegal3() throws TriangleException {
+        thrown.expect(TriangleException.class);
         new Triangle(7, 3, 2);
     }
 }

data/tracks/kotlin/config.json

@@ -73,6 +73,11 @@
       "slug": "bob",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "perfect-numbers",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "leap",

data/tracks/kotlin/exercises/build.gradle

@@ -1,5 +1,14 @@
 subprojects {
   afterEvaluate { Project project ->
+
+    configurations {
+      starterSourceCompile.extendsFrom compile
+      starterSourceRuntime.extendsFrom runtime
+
+      exerciseTestsCompile.extendsFrom testCompile
+      exerciseTestsRuntime.extendsFrom testRuntime
+    }
+
     sourceSets {
       // Verify that the tests are working by running them against the example code.
       // By replacing the "main" sourceSet with the example code we avoid any collisions
@@ -18,6 +27,14 @@ subprojects {
         println "  (source = " + compileTask.source.asPath + ")"
       }
 
+      exerciseTests {
+        kotlin {
+          srcDirs = ["src/test/kotlin"]
+          compileClasspath += main.output
+          runtimeClasspath += main.output
+        }
+      }
+
       // In lieu of being able to disable @Ignore in JUnit tests, we filter
       // those annotations, placing the edited tests in the path named here.
       test {

data/tracks/kotlin/exercises/perfect-numbers/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.0.6'
+  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/perfect-numbers/src/example/kotlin/NaturalNumber.kt

@@ -0,0 +1,17 @@
+
+enum class Classification {
+    DEFICIENT, PERFECT, ABUNDANT
+}
+
+fun classify(naturalNumber: Int): Classification {
+    require(naturalNumber >= 0, { "$naturalNumber is not a natural number" })
+
+    val aliquotSum = naturalNumber.aliquotSum()
+    return when {
+        aliquotSum == naturalNumber -> Classification.PERFECT
+        aliquotSum > naturalNumber -> Classification.ABUNDANT
+        else -> Classification.DEFICIENT
+    }
+}
+
+fun Int.aliquotSum(): Int = (1 until this).filter { this % it == 0 }.sum()

data/tracks/kotlin/exercises/perfect-numbers/src/main/kotlin/NaturalNumber.kt

@@ -0,0 +1,8 @@
+
+enum class Classification {
+    DEFICIENT, PERFECT, ABUNDANT
+}
+
+fun classify(naturalNumber: Int): Classification {
+    return Classification.DEFICIENT
+}

data/tracks/kotlin/exercises/perfect-numbers/src/test/kotlin/PerfectNumbersTest.kt

@@ -0,0 +1,67 @@
+import org.junit.Ignore
+import org.junit.Test
+
+import org.junit.Assert.assertEquals
+
+class NaturalNumberTest {
+
+    @Test
+    fun smallPerfectNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.PERFECT, classify(6))
+    }
+
+    @Ignore
+    @Test
+    fun mediumPerfectNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.PERFECT, classify(28))
+    }
+
+    @Ignore
+    @Test
+    fun largePerfectNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.PERFECT, classify(33550336))
+    }
+
+    @Ignore
+    @Test
+    fun smallAbundantNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.ABUNDANT, classify(12))
+    }
+
+    @Ignore
+    @Test
+    fun mediumAbundantNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.ABUNDANT, classify(24))
+    }
+
+    @Ignore
+    @Test
+    fun largeAbundantNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.ABUNDANT, classify(33550335))
+    }
+
+    @Ignore
+    @Test
+    fun smallDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(8))
+    }
+
+    @Ignore
+    @Test
+    fun mediumNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(31))
+    }
+
+    @Ignore
+    @Test
+    fun largeDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(33550337))
+    }
+
+    @Ignore
+    @Test(expected = RuntimeException::class)
+    fun mustProvideNaturalNumber() {
+        assertEquals(Classification.DEFICIENT, classify(-1))
+    }
+
+}

data/tracks/kotlin/exercises/settings.gradle

@@ -21,6 +21,7 @@ include 'nth-prime'
 include 'nucleotide-count'
 include 'pangram'
 include 'pascals-triangle'
+include 'perfect-numbers'
 include 'phone-number'
 include 'pig-latin'
 include 'raindrops'

data/tracks/lua/exercises/hamming/example.lua

@@ -1,6 +1,7 @@
 local Hamming = {}
 
 function Hamming.compute(a,b)
+  if #a ~= #b then return -1 end
   local distance = 0
   for i = 1, a:len() do
     if (a:sub(i, i) ~= b:sub(i, i)) then