trackler 2.1.0.18 → 2.1.0.19

data/tracks/go/exercises/variable-length-quantity/cases_test.go

@@ -0,0 +1,161 @@
+package variablelengthquantity
+
+// Source: exercism/x-common
+// Commit: d6a62f7 variable-length-quantity: Fix canonical-data.json formatting
+// x-common version: 1.0.0
+
+// Encode a series of integers, producing a series of bytes.
+var encodeTestCases = []struct {
+	description string
+	input       []uint32
+	output      []byte
+}{
+	{
+		"zero",
+		[]uint32{0x0},
+		[]byte{0x0},
+	},
+	{
+		"arbitrary single byte",
+		[]uint32{0x40},
+		[]byte{0x40},
+	},
+	{
+		"largest single byte",
+		[]uint32{0x7f},
+		[]byte{0x7f},
+	},
+	{
+		"smallest double byte",
+		[]uint32{0x80},
+		[]byte{0x81, 0x0},
+	},
+	{
+		"arbitrary double byte",
+		[]uint32{0x2000},
+		[]byte{0xc0, 0x0},
+	},
+	{
+		"largest double byte",
+		[]uint32{0x3fff},
+		[]byte{0xff, 0x7f},
+	},
+	{
+		"smallest triple byte",
+		[]uint32{0x4000},
+		[]byte{0x81, 0x80, 0x0},
+	},
+	{
+		"arbitrary triple byte",
+		[]uint32{0x100000},
+		[]byte{0xc0, 0x80, 0x0},
+	},
+	{
+		"largest triple byte",
+		[]uint32{0x1fffff},
+		[]byte{0xff, 0xff, 0x7f},
+	},
+	{
+		"smallest quadruple byte",
+		[]uint32{0x200000},
+		[]byte{0x81, 0x80, 0x80, 0x0},
+	},
+	{
+		"arbitrary quadruple byte",
+		[]uint32{0x8000000},
+		[]byte{0xc0, 0x80, 0x80, 0x0},
+	},
+	{
+		"largest quadruple byte",
+		[]uint32{0xfffffff},
+		[]byte{0xff, 0xff, 0xff, 0x7f},
+	},
+	{
+		"smallest quintuple byte",
+		[]uint32{0x10000000},
+		[]byte{0x81, 0x80, 0x80, 0x80, 0x0},
+	},
+	{
+		"arbitrary quintuple byte",
+		[]uint32{0xff000000},
+		[]byte{0x8f, 0xf8, 0x80, 0x80, 0x0},
+	},
+	{
+		"maximum 32-bit integer input",
+		[]uint32{0xffffffff},
+		[]byte{0x8f, 0xff, 0xff, 0xff, 0x7f},
+	},
+	{
+		"two single-byte values",
+		[]uint32{0x40, 0x7f},
+		[]byte{0x40, 0x7f},
+	},
+	{
+		"two multi-byte values",
+		[]uint32{0x4000, 0x123456},
+		[]byte{0x81, 0x80, 0x0, 0xc8, 0xe8, 0x56},
+	},
+	{
+		"many multi-byte values",
+		[]uint32{0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000},
+		[]byte{0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0},
+	},
+}
+
+// Decode a series of bytes, producing a series of integers.
+var decodeTestCases = []struct {
+	description string
+	input       []byte
+	output      []uint32 // nil slice indicates error expected.
+	size        int
+}{
+
+	{
+		"one byte",
+		[]byte{0x7f},
+		[]uint32{0x7f},
+		1,
+	},
+	{
+		"two bytes",
+		[]byte{0xc0, 0x0},
+		[]uint32{0x2000},
+		2,
+	},
+	{
+		"three bytes",
+		[]byte{0xff, 0xff, 0x7f},
+		[]uint32{0x1fffff},
+		3,
+	},
+	{
+		"four bytes",
+		[]byte{0x81, 0x80, 0x80, 0x0},
+		[]uint32{0x200000},
+		4,
+	},
+	{
+		"maximum 32-bit integer",
+		[]byte{0x8f, 0xff, 0xff, 0xff, 0x7f},
+		[]uint32{0xffffffff},
+		5,
+	},
+	{
+		"incomplete sequence causes error",
+		[]byte{0xff},
+		[]uint32(nil),
+		1,
+	},
+	{
+		"incomplete sequence causes error, even if value is zero",
+		[]byte{0x80},
+		[]uint32(nil),
+		1,
+	},
+	{
+		"multiple values",
+		[]byte{0xc0, 0x0, 0xc8, 0xe8, 0x56, 0xff, 0xff, 0xff, 0x7f, 0x0, 0xff, 0x7f, 0x81, 0x80, 0x0},
+		[]uint32{0x2000, 0x123456, 0xfffffff, 0x0, 0x3fff, 0x4000},
+		15,
+	},
+}

data/tracks/go/exercises/variable-length-quantity/example.go

@@ -1,9 +1,13 @@
 package variablelengthquantity
 
-const testVersion = 2
+import "errors"
 
-// EncodeVarint returns the varint encoding of x.
-func EncodeVarint(x uint32) []byte {
+const testVersion = 3
+
+var ErrUnterminatedSequence = errors.New("unterminated sequence")
+
+// encodeInt returns the varint encoding of x.
+func encodeInt(x uint32) []byte {
 	if x>>7 == 0 {
 		return []byte{
 			byte(x),
@@ -25,7 +29,17 @@ func EncodeVarint(x uint32) []byte {
 		}
 	}
 
+	if x>>28 == 0 {
+		return []byte{
+			byte(0x80 | x>>21),
+			byte(0x80 | x>>14),
+			byte(0x80 | x>>6),
+			byte(127 & x),
+		}
+	}
+
 	return []byte{
+		byte(0x80 | x>>28),
 		byte(0x80 | x>>21),
 		byte(0x80 | x>>14),
 		byte(0x80 | x>>7),
@@ -33,26 +47,55 @@ func EncodeVarint(x uint32) []byte {
 	}
 }
 
-// DecodeVarint reads a varint-encoded integer from the slice.
+// decodeInt reads a varint-encoded integer from the slice.
 // It returns the integer and the number of bytes consumed, or
 // zero if there is not enough.
-func DecodeVarint(buf []byte) (x uint32, n int) {
+func decodeInt(buf []byte) (x uint32, n int, err error) {
 	if len(buf) < 1 {
-		return 0, 0
+		return 0, 0, nil
 	}
 
-	if buf[0] <= 0x80 {
-		return uint32(buf[0]), 1
+	if buf[0] < 0x80 {
+		return uint32(buf[0]), 1, nil
 	}
 
 	var b byte
 	for n, b = range buf {
 		x = x << 7
-		x |= uint32(b) & 0x7F
+		x |= uint32(b) & 0x7f
 		if (b & 0x80) == 0 {
-			return x, n + 1
+			return x, n + 1, nil
 		}
 	}
 
-	return x, 0
+	return x, 0, ErrUnterminatedSequence
+}
+
+// EncodeVarint encodes a slice of uint32 into a var-int encoded bytes.
+func EncodeVarint(xa []uint32) []byte {
+	result := make([]byte, 0)
+	for _, x := range xa {
+		result = append(result, encodeInt(x)...)
+	}
+	return result
+}
+
+// DecodeVarint decodes a buffer of var-int encoded values into
+// a slice of uint32 values; an error is returned if buf doesn't
+// decode var-int successfully.
+func DecodeVarint(buf []byte) (ra []uint32, n int, err error) {
+	if len(buf) == 0 {
+		return []uint32{0}, 1, nil
+	}
+	usedBytes := 0
+	ra = make([]uint32, 0)
+	for usedBytes < len(buf) {
+		r, nUsed, err := decodeInt(buf[usedBytes:])
+		if err != nil {
+			return nil, usedBytes, err
+		}
+		ra = append(ra, r)
+		usedBytes += nUsed
+	}
+	return ra, usedBytes, nil
 }

data/tracks/go/exercises/variable-length-quantity/variable_length_quantity_test.go

@@ -2,28 +2,11 @@ package variablelengthquantity
 
 import (
 	"bytes"
+	"reflect"
 	"testing"
 )
 
-const targetTestVersion = 2
-
-var testCases = []struct {
-	input  []byte
-	output uint32
-	size   int
-}{
-	0:  {[]byte{0x7F}, 127, 1},
-	1:  {[]byte{0x81, 0x00}, 128, 2},
-	2:  {[]byte{0xC0, 0x00}, 8192, 2},
-	3:  {[]byte{0xFF, 0x7F}, 16383, 2},
-	4:  {[]byte{0x81, 0x80, 0x00}, 16384, 3},
-	5:  {[]byte{0xFF, 0xFF, 0x7F}, 2097151, 3},
-	6:  {[]byte{0x81, 0x80, 0x80, 0x00}, 2097152, 4},
-	7:  {[]byte{0xC0, 0x80, 0x80, 0x00}, 134217728, 4},
-	8:  {[]byte{0xFF, 0xFF, 0xFF, 0x7F}, 268435455, 4},
-	9:  {[]byte{0x82, 0x00}, 256, 2},
-	10: {[]byte{0x81, 0x10}, 144, 2},
-}
+const targetTestVersion = 3
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
@@ -32,24 +15,29 @@ func TestTestVersion(t *testing.T) {
 }
 
 func TestDecodeVarint(t *testing.T) {
-	for i, tc := range testCases {
-		o, size := DecodeVarint(tc.input)
-		if o != tc.output {
-			t.Fatalf("FAIL: case %d - expected %d got %d\n", i, tc.output, o)
+	for i, tc := range decodeTestCases {
+		o, size, err := DecodeVarint(tc.input)
+		if err != nil {
+			var _ error = err
+			if tc.output != nil {
+				t.Fatalf("FAIL: case %d | %s\nexpected %#v got error: %q\n", i, tc.description, tc.output, err)
+			}
+		} else if tc.output == nil {
+			t.Fatalf("FAIL: case %d | %s\nexpected error, got %#v\n", i, tc.description, o)
+		} else if !reflect.DeepEqual(o, tc.output) {
+			t.Fatalf("FAIL: case %d | %s\nexpected\t%#v\ngot\t\t%#v\n", i, tc.description, tc.output, o)
 		} else if size != tc.size {
-			t.Fatalf("FAIL: case %d - expected encoding size of %d bytes\ngot %d bytes\n", i, tc.size, size)
-		} else {
-			t.Logf("PASS: case %d - %#v\n", i, tc.input)
+			t.Fatalf("FAIL: case %d | %s\n expected encoding size of %d bytes\ngot %d bytes\n", i, tc.description, tc.size, size)
 		}
+		t.Logf("PASS: case %d | %s\n", i, tc.description)
 	}
 }
 
 func TestEncodeVarint(t *testing.T) {
-	for i, tc := range testCases {
-		if encoded := EncodeVarint(tc.output); bytes.Compare(encoded, tc.input) != 0 {
-			t.Fatalf("FAIL: case %d - %d \nexpected\t%#v\ngot\t\t%#v\n", i, tc.output, tc.input, encoded)
-		} else {
-			t.Logf("PASS: case %d - %#v\n", i, tc.input)
+	for i, tc := range encodeTestCases {
+		if encoded := EncodeVarint(tc.input); bytes.Compare(encoded, tc.output) != 0 {
+			t.Fatalf("FAIL: case %d | %s\nexpected\t%#v\ngot\t\t%#v\n", i, tc.description, tc.output, encoded)
 		}
+		t.Logf("PASS: case %d | %s\n", i, tc.description)
 	}
 }

data/tracks/go/exercises/word-count/.meta/gen.go

@@ -1,5 +1,3 @@
-// +build ignore
-
 package main
 
 import (

data/tracks/java/exercises/acronym/src/test/java/AcronymTest.java

@@ -3,6 +3,9 @@ import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 
+/*
+ * version: 1.1.0
+ */
 public class AcronymTest {
 
     @Test
@@ -20,14 +23,6 @@ public class AcronymTest {
         assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore("Remove to run test")
-    @Test
-    public void fromInconsistentlyCasedPhrases() {
-        final String phrase = "HyperText Markup Language";
-        final String expected = "HTML";
-        assertEquals(expected, new Acronym(phrase).get());
-    }
-
     @Ignore("Remove to run test")
     @Test
     public void fromPhrasesWithPunctuation() {
@@ -60,12 +55,4 @@ public class AcronymTest {
         assertEquals(expected, new Acronym(phrase).get());
     }
 
-    @Ignore("Remove to run test")
-    @Test
-    public void fromPhraseWithSingleLetterWord() {
-        final String phrase = "Cat in a Hat";
-        final String expected = "CIAH";
-        assertEquals(expected, new Acronym(phrase).get());
-    }
-
 }

data/tracks/java/exercises/diamond/src/test/java/DiamondPrinterTest.java

@@ -9,7 +9,7 @@ import static java.util.Collections.singletonList;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
-public final class DiamondPrinterTest {
+public class DiamondPrinterTest {
     private DiamondPrinter diamondPrinter;
     
     @Before

data/tracks/java/exercises/hello-world/HINT.md

@@ -0,0 +1,7 @@
+The default implementation for this exercise uses an [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/) 
+which will cause the test to fail with the provided error message.
+This particular exception type, [UnsupportedOperationException](http://docs.oracle.com/javase/8/docs/api/?java/lang/UnsupportedOperationException.html), 
+is commonly thrown to alert developers that a method has not yet been implemented.
+Throwing exceptions in this manner means the tests will compile but not pass right away.
+
+To make the test pass you need to remove the line which throws the exception and replace it with your implementation of the method.

data/tracks/java/exercises/largest-series-product/src/test/java/LargestSeriesProductCalculatorTest.java

@@ -5,7 +5,7 @@ import org.junit.rules.ExpectedException;
 
 import static org.junit.Assert.assertEquals;
 
-public final class LargestSeriesProductCalculatorTest {
+public class LargestSeriesProductCalculatorTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and

data/tracks/java/exercises/linked-list/src/test/java/DoublyLinkedListTest.java

@@ -1,68 +1,78 @@
-import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
 
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
 
 public class DoublyLinkedListTest {
-    private DoublyLinkedList<Integer> subject;
-
-    @Before
-    public void setUp() {
-        subject = new DoublyLinkedList<>();
-    }
-
 
     @Test
     public void testPushPop() {
-        subject.push(10);
-        subject.push(20);
-        assertThat(subject.pop(), is(20));
-        assertThat(subject.pop(), is(10));
+        DoublyLinkedList<Integer> list = new DoublyLinkedList<>();
+
+        list.push(10);
+        list.push(20);
+
+        assertThat(list.pop(), is(20));
+        assertThat(list.pop(), is(10));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPushShift() {
-        subject.push(10);
-        subject.push(20);
-        assertThat(subject.shift(), is(10));
-        assertThat(subject.shift(), is(20));
+        DoublyLinkedList<String> list = new DoublyLinkedList<>();
+
+        list.push("10");
+        list.push("20");
+
+        assertThat(list.shift(), is("10"));
+        assertThat(list.shift(), is("20"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnshiftShift() {
-        subject.unshift(10);
-        subject.unshift(20);
-        assertThat(subject.shift(), is(20));
-        assertThat(subject.shift(), is(10));
+        DoublyLinkedList<Character> list = new DoublyLinkedList<>();
+
+        list.unshift('1');
+        list.unshift('2');
+
+        assertThat(list.shift(), is('2'));
+        assertThat(list.shift(), is('1'));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnshiftPop() {
-        subject.unshift(10);
-        subject.unshift(20);
-        assertThat(subject.pop(), is(10));
-        assertThat(subject.pop(), is(20));
+        DoublyLinkedList<Integer> list = new DoublyLinkedList<>();
+
+        list.unshift(10);
+        list.unshift(20);
+
+        assertThat(list.pop(), is(10));
+        assertThat(list.pop(), is(20));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testExample() {
-        subject.push(10);
-        subject.push(20);
-        assertThat(subject.pop(), is(20));
-
-        subject.push(30);
-        assertThat(subject.shift(), is(10));
-
-        subject.unshift(40);
-        subject.push(50);
-        assertThat(subject.shift(), is(40));
-        assertThat(subject.pop(), is(50));
-        assertThat(subject.shift(), is(30));
+        DoublyLinkedList<String> list = new DoublyLinkedList<>();
+
+        list.push("ten");
+        list.push("twenty");
+
+        assertThat(list.pop(), is("twenty"));
+
+        list.push("thirty");
+
+        assertThat(list.shift(), is("ten"));
+
+        list.unshift("forty");
+        list.push("fifty");
+
+        assertThat(list.shift(), is("forty"));
+        assertThat(list.pop(), is("fifty"));
+        assertThat(list.shift(), is("thirty"));
     }
+
 }

data/tracks/java/exercises/luhn/src/main/java/LuhnValidator.java

@@ -0,0 +1,7 @@
+final class LuhnValidator {
+
+    boolean isValid(String candidate) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

@@ -9,7 +9,7 @@ import java.util.List;
 
 import static org.junit.Assert.assertEquals;
 
-public final class MinesweeperBoardTest {
+public class MinesweeperBoardTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and

data/tracks/java/exercises/perfect-numbers/src/test/java/NaturalNumberTest.java

@@ -9,7 +9,7 @@ import static org.junit.Assert.assertEquals;
  * version: 1.0.0
  * https://github.com/exercism/x-common/blob/19d0c7714ce664a1ad762af624c17f8e269fa8b2/exercises/perfect-numbers/canonical-data.json
  */
-public final class NaturalNumberTest {
+public class NaturalNumberTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and

data/tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -6,7 +6,7 @@ import org.junit.rules.ExpectedException;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-public final class QueenAttackCalculatorTest {
+public class QueenAttackCalculatorTest {
 
     /*
      * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and

data/tracks/java/exercises/rectangles/src/test/java/RectangleCounterTest.java

@@ -4,7 +4,7 @@ import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
 
-public final class RectangleCounterTest {
+public class RectangleCounterTest {
 
     private RectangleCounter rectangleCounter;
 

data/tracks/java/exercises/secret-handshake/src/main/java/HandshakeCalculator.java

@@ -1,5 +1,9 @@
-final class HandshakeCalculator {
+import java.util.List;
 
+final class HandshakeCalculator {
 
+    List<Signal> calculateHandshake(int number) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
 
 }

data/tracks/java/exercises/sum-of-multiples/src/main/java/SumOfMultiples.java

@@ -1,3 +1,11 @@
-public class SumOfMultiples {
-    
+class SumOfMultiples {
+
+    SumOfMultiples(int number, int[] set) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getSum() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
 }

data/tracks/java/exercises/triangle/src/example/java/Triangle.java

@@ -1,13 +1,13 @@
 import java.util.HashSet;
 import java.util.Set;
 
-public class Triangle {
+class Triangle {
 
     private double side1;
     private double side2;
     private double side3;
 
-    public Triangle(double side1, double side2, double side3) throws TriangleException {
+    Triangle(double side1, double side2, double side3) throws TriangleException {
         this.side1 = side1;
         this.side2 = side2;
         this.side3 = side3;
@@ -17,7 +17,7 @@ public class Triangle {
         }
     }
 
-    public TriangleKind getKind() {
+    TriangleKind getKind() {
         int uniqueSides = getNumberOfUniqueSides();
 
         if (uniqueSides == 1) {
@@ -43,8 +43,7 @@ public class Triangle {
         return side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1;
     }
 
-
-    public int getNumberOfUniqueSides() {
+    private int getNumberOfUniqueSides() {
         Set<Double> sides = new HashSet<>();
 
         sides.add(side1);
@@ -53,4 +52,5 @@ public class Triangle {
 
         return sides.size();
     }
+
 }

data/tracks/java/exercises/triangle/src/example/java/TriangleException.java

@@ -1,5 +1,3 @@
-public class TriangleException extends Exception {
+class TriangleException extends Exception {
 
-    public TriangleException() {
-    }
 }

data/tracks/java/exercises/triangle/src/main/java/Triangle.java

@@ -0,0 +1,11 @@
+class Triangle {
+
+    Triangle(double side1, double side2, double side3) throws TriangleException {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    TriangleKind getKind() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

data/tracks/java/exercises/triangle/src/main/java/TriangleException.java

@@ -1,5 +1,3 @@
-public class TriangleException extends Exception {
+class TriangleException extends Exception {
 
-    public TriangleException() {
-    }
 }

data/tracks/javascript/.github/stale.yml

@@ -0,0 +1,6 @@
+# Issues or Pull Requests with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+  - good first patch
+  - first-timers only