Normalized EOF's

config.json

-{
-  "slug": "java",
-  "language": "Java",
-  "repository": "https://github.com/exercism/xjava",
-  "active": true,
-
-  "exercises": [
-    {
-      "slug": "hello-world",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "rna-transcription",
-      "difficulty": 2,
-      "topics": []
-    },
-    {
-      "slug": "pangram",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "hamming",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "gigasecond",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "space-age",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "acronym",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "scrabble-score",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "raindrops",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "difference-of-squares",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "secret-handshake",
-      "difficulty": 3,
-      "topics": []
-    },
-    {
-      "slug": "sum-of-multiples",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "luhn",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "matrix",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "triangle",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "largest-series-product",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "sieve",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "twelve-days",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "nth-prime",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "diamond",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "isogram",
-      "difficulty": 4,
-      "topics": []
-    },
-    {
-      "slug": "flatten-array",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "pig-latin",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "phone-number",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "accumulate",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "nucleotide-count",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "word-count",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "robot-name",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "prime-factors",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "allergies",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "bob",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "pascals-triangle",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "bracket-push",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "series",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "atbash-cipher",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "strain",
-      "difficulty": 5,
-      "topics": []
-    },
-    {
-      "slug": "roman-numerals",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "beer-song",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "queen-attack",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "etl",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "linked-list",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "grade-school",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "robot-simulator",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "binary-search",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "minesweeper",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "wordy",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "all-your-base",
-      "difficulty": 6,
-      "topics": []
-    },
-    {
-      "slug": "anagram",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "sublist",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "simple-linked-list",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "binary-search-tree",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "rectangles",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "meetup",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "crypto-square",
-      "difficulty": 7,
-      "topics": []
-    },
-    {
-      "slug": "simple-cipher",
-      "difficulty": 8,
-      "topics": []
-    },
-    {
-      "slug": "palindrome-products",
-      "difficulty": 8,
-      "topics": []
-    },
-    {
-      "slug": "pythagorean-triplet",
-      "difficulty": 9,
-      "topics": []
-    },
-    {
-      "slug": "custom-set",
-      "difficulty": 10,
-      "topics": []
-    },
-    {
-      "slug": "clock",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "perfect-numbers",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "change",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "list-ops",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "ocr-numbers",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "book-store",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "saddle-points",
-      "difficulty": 1,
-      "topics": []
-    },
-    {
-      "slug": "run-length-encoding",
-      "difficulty": 1,
-      "topics": []
-    }
-  ],
-  "deprecated": [
-    "binary",
-    "hexadecimal",
-    "octal",
-    "trinary"
-  ],
-  "ignored": [
-    "_template",
-    ".gradle",
-    "build",
-    "docs",
-    "gradle",
-    "scripts"
-  ],
-  "foregone": [
-    "leap",
-    "grains",
-    "say"
-  ]
-}
-
+{
+  "slug": "java",
+  "language": "Java",
+  "repository": "https://github.com/exercism/xjava",
+  "active": true,
+
+  "exercises": [
+    {
+      "slug": "hello-world",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "rna-transcription",
+      "difficulty": 2,
+      "topics": []
+    },
+    {
+      "slug": "pangram",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "hamming",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "gigasecond",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "space-age",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "acronym",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "scrabble-score",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "difference-of-squares",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "secret-handshake",
+      "difficulty": 3,
+      "topics": []
+    },
+    {
+      "slug": "sum-of-multiples",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "luhn",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "matrix",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "triangle",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "largest-series-product",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "sieve",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "twelve-days",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "nth-prime",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "diamond",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "isogram",
+      "difficulty": 4,
+      "topics": []
+    },
+    {
+      "slug": "flatten-array",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "pig-latin",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "phone-number",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "accumulate",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "nucleotide-count",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "word-count",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "robot-name",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "prime-factors",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "allergies",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "bob",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "pascals-triangle",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "bracket-push",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "series",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "atbash-cipher",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "strain",
+      "difficulty": 5,
+      "topics": []
+    },
+    {
+      "slug": "roman-numerals",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "beer-song",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "queen-attack",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "etl",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "linked-list",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "grade-school",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "robot-simulator",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "binary-search",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "minesweeper",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "wordy",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "all-your-base",
+      "difficulty": 6,
+      "topics": []
+    },
+    {
+      "slug": "anagram",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "sublist",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "simple-linked-list",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "binary-search-tree",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "rectangles",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "meetup",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "crypto-square",
+      "difficulty": 7,
+      "topics": []
+    },
+    {
+      "slug": "simple-cipher",
+      "difficulty": 8,
+      "topics": []
+    },
+    {
+      "slug": "palindrome-products",
+      "difficulty": 8,
+      "topics": []
+    },
+    {
+      "slug": "pythagorean-triplet",
+      "difficulty": 9,
+      "topics": []
+    },
+    {
+      "slug": "custom-set",
+      "difficulty": 10,
+      "topics": []
+    },
+    {
+      "slug": "clock",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "perfect-numbers",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "change",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "list-ops",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "ocr-numbers",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "book-store",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "saddle-points",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 1,
+      "topics": []
+    }
+  ],
+  "deprecated": [
+    "binary",
+    "hexadecimal",
+    "octal",
+    "trinary"
+  ],
+  "ignored": [
+    "_template",
+    ".gradle",
+    "build",
+    "docs",
+    "gradle",
+    "scripts"
+  ],
+  "foregone": [
+    "leap",
+    "grains",
+    "say"
+  ]
+}
+

exercises/run-length-encoding/build.gradle

-apply plugin: "java"
-apply plugin: "eclipse"
-apply plugin: "idea"
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    testCompile "junit:junit:4.12"
-}
-test {
-    testLogging {
-        exceptionFormat = 'full'
-        events = ["passed", "failed", "skipped"]
-    }
-}
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/run-length-encoding/src/example/java/RunLengthEncoding.java

-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class RunLengthEncoding {
-    public String encode(String data) {
-
-        StringBuilder encodedDataBuilder = new StringBuilder();
-
-        if (data.length() == 0) {
-            return data;
-        }
-
-        int previousCharCount = 1;
-        char previousChar = data.charAt(0);
-
-        for (int i = 1; i < data.length(); i++) {
-            char currentChar = data.charAt(i);
-
-            if (previousChar == currentChar) {
-                previousCharCount++;
-            }
-
-            if (previousChar != currentChar || i == data.length() - 1) {
-                addChars(encodedDataBuilder, previousChar, previousCharCount);
-
-                if (previousChar != currentChar && i == data.length() - 1) {
-                    addChars(encodedDataBuilder, currentChar, 1);
-                }
-
-                previousChar = currentChar;
-                previousCharCount = 1;
-            }
-        }
-
-        return encodedDataBuilder.toString();
-    }
-
-    public void addChars(StringBuilder toAddTo, char toAdd, int countOfChar) {
-        if(countOfChar != 1) {
-            toAddTo.append(countOfChar);
-        }
-
-        countOfChar.append(toAdd);
-    }
-
-    public String decode(String encodedData) {
-        StringBuilder decodedData = new StringBuilder();
-        Pattern pattern = Pattern.compile("[0-9]+|[a-zA-Z\\s]");
-        Matcher matcher = pattern.matcher(encodedData);
-
-        while (matcher.find()) {
-            try {
-                int number = Integer.parseInt(matcher.group());
-
-                matcher.find();
-
-                for (int i = 0; i<number; i++) {
-                    decodedData.append(matcher.group());
-                }
-            } catch (NumberFormatException e) {
-                decodedData.append(matcher.group());
-            }
-        }
-
-        return decodedData.toString();
-    }
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class RunLengthEncoding {
+    public String encode(String data) {
+
+        StringBuilder encodedDataBuilder = new StringBuilder();
+
+        if (data.length() == 0) {
+            return data;
+        }
+
+        int previousCharCount = 1;
+        char previousChar = data.charAt(0);
+
+        for (int i = 1; i < data.length(); i++) {
+            char currentChar = data.charAt(i);
+
+            if (previousChar == currentChar) {
+                previousCharCount++;
+            }
+
+            if (previousChar != currentChar || i == data.length() - 1) {
+                addChars(encodedDataBuilder, previousChar, previousCharCount);
+
+                if (previousChar != currentChar && i == data.length() - 1) {
+                    addChars(encodedDataBuilder, currentChar, 1);
+                }
+
+                previousChar = currentChar;
+                previousCharCount = 1;
+            }
+        }
+
+        return encodedDataBuilder.toString();
+    }
+
+    public void addChars(StringBuilder toAddTo, char toAdd, int countOfChar) {
+        if(countOfChar != 1) {
+            toAddTo.append(countOfChar);
+        }
+
+        countOfChar.append(toAdd);
+    }
+
+    public String decode(String encodedData) {
+        StringBuilder decodedData = new StringBuilder();
+        Pattern pattern = Pattern.compile("[0-9]+|[a-zA-Z\\s]");
+        Matcher matcher = pattern.matcher(encodedData);
+
+        while (matcher.find()) {
+            try {
+                int number = Integer.parseInt(matcher.group());
+
+                matcher.find();
+
+                for (int i = 0; i<number; i++) {
+                    decodedData.append(matcher.group());
+                }
+            } catch (NumberFormatException e) {
+                decodedData.append(matcher.group());
+            }
+        }
+
+        return decodedData.toString();
+    }
 }

exercises/run-length-encoding/src/main/java/RunLengthEncoding.java

-public class RunLengthEncoding {
-    public String encode(String data) {
-        throw new UnsupportedOperationException("Method has not been implemented yet.");
-    }
-
-    public String decode(String encodedData) {
-        throw new UnsupportedOperationException("Method has not been implemented yet.");
-    }
-}
+public class RunLengthEncoding {
+    public String encode(String data) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+
+    public String decode(String encodedData) {
+        throw new UnsupportedOperationException("Method has not been implemented yet.");
+    }
+}

exercises/run-length-encoding/src/test/java/RunLengthEncodingTest.java

-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class RunLengthEncodingTest {
-    private RunLengthEncoding runLengthEncoding;
-
-    @Before
-    public void setUp() {
-        runLengthEncoding = new RunLengthEncoding();
-    }
-
-    @Test
-    public void encodeEmpty() {
-        Assert.assertEquals("", runLengthEncoding.encode(""));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeWithOnlySingleValues() {
-        Assert.assertEquals("XYZ", runLengthEncoding.encode("XYZ"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeWithNoSingleValues() {
-        Assert.assertEquals(
-                "2A3B4C",
-                runLengthEncoding.encode("AABBBCCCC"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeWithMixedValues() {
-        Assert.assertEquals(
-                "12WB12W3B24WB",
-                runLengthEncoding.encode(
-                        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeWithWhitespaceValues() {
-        Assert.assertEquals(
-                "2 hs2q q2w2 ",
-                runLengthEncoding.encode("  hsqq qww  "));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeWithLowercaseValues() {
-        Assert.assertEquals(
-                "2a3b4c",
-                runLengthEncoding.encode("aabbbcccc"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeEmpty() {
-        Assert.assertEquals("", runLengthEncoding.decode(""));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeWithOnlySingleValues() {
-        Assert.assertEquals(
-                "XYZ",
-                runLengthEncoding.decode("XYZ"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeWithNoSingleValues() {
-        Assert.assertEquals(
-                "AABBBCCCC",
-                runLengthEncoding.decode("2A3B4C"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeWithMixedValues() {
-        Assert.assertEquals(
-                "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB",
-                runLengthEncoding.decode("12WB12W3B24WB"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeWithWhitespaceValues() {
-        Assert.assertEquals(
-                "  hsqq qww  ",
-                runLengthEncoding.decode("2 hs2q q2w2 "));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void decodeWithLowercaseValues() {
-        Assert.assertEquals(
-                "aabbbcccc",
-                runLengthEncoding.decode("2a3b4c"));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void encodeThenDecode() {
-        String inOut = "zzz ZZ  zZ";
-        String encoded = runLengthEncoding.encode(inOut);
-        Assert.assertEquals(inOut, runLengthEncoding.decode(encoded));
-    }
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class RunLengthEncodingTest {
+    private RunLengthEncoding runLengthEncoding;
+
+    @Before
+    public void setUp() {
+        runLengthEncoding = new RunLengthEncoding();
+    }
+
+    @Test
+    public void encodeEmpty() {
+        Assert.assertEquals("", runLengthEncoding.encode(""));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithOnlySingleValues() {
+        Assert.assertEquals("XYZ", runLengthEncoding.encode("XYZ"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithNoSingleValues() {
+        Assert.assertEquals(
+                "2A3B4C",
+                runLengthEncoding.encode("AABBBCCCC"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithMixedValues() {
+        Assert.assertEquals(
+                "12WB12W3B24WB",
+                runLengthEncoding.encode(
+                        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithWhitespaceValues() {
+        Assert.assertEquals(
+                "2 hs2q q2w2 ",
+                runLengthEncoding.encode("  hsqq qww  "));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeWithLowercaseValues() {
+        Assert.assertEquals(
+                "2a3b4c",
+                runLengthEncoding.encode("aabbbcccc"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeEmpty() {
+        Assert.assertEquals("", runLengthEncoding.decode(""));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithOnlySingleValues() {
+        Assert.assertEquals(
+                "XYZ",
+                runLengthEncoding.decode("XYZ"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithNoSingleValues() {
+        Assert.assertEquals(
+                "AABBBCCCC",
+                runLengthEncoding.decode("2A3B4C"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithMixedValues() {
+        Assert.assertEquals(
+                "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB",
+                runLengthEncoding.decode("12WB12W3B24WB"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithWhitespaceValues() {
+        Assert.assertEquals(
+                "  hsqq qww  ",
+                runLengthEncoding.decode("2 hs2q q2w2 "));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void decodeWithLowercaseValues() {
+        Assert.assertEquals(
+                "aabbbcccc",
+                runLengthEncoding.decode("2a3b4c"));
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void encodeThenDecode() {
+        String inOut = "zzz ZZ  zZ";
+        String encoded = runLengthEncoding.encode(inOut);
+        Assert.assertEquals(inOut, runLengthEncoding.decode(encoded));
+    }
 }