trackler 2.1.0.48 → 2.1.0.49

data/tracks/java/CONTRIBUTING.md

@@ -0,0 +1,8 @@
+Hi! Thanks for contributing to the Exercism Java track!
+
+Before opening your pull request, please review the track policies linked below and make sure your changes comply with them all. This helps us focus our review time on the more important aspects of your changes.
+
+- [Prefer instance methods](https://github.com/exercism/java/blob/master/POLICIES.md#prefer-instance-methods)
+- [Starter implementations](https://github.com/exercism/java/blob/master/POLICIES.md#starter-implementations)
+- [Ignore noninitial tests](https://github.com/exercism/java/blob/master/POLICIES.md#ignore-noninitial-tests)
+- [Multiple file submissions](https://github.com/exercism/java/blob/master/POLICIES.md#multiple-file-submissions)

data/tracks/java/POLICIES.md

@@ -38,7 +38,7 @@ References: [[1](https://github.com/exercism/java/issues/177#issuecomment-261291
     `throw new UnsupportedOperationException("Delete this statement and write your own implementation.");`
 > - Exercises 11-20: provide stubs for all constructors and methods required by the first test; comment-out the bodies of any tests that require non-stubbed constructors or methods. Stubs should include the following body:
     `throw new UnsupportedOperationException("Delete this statement and provide your own implementation.");`
-> - Exercises 21+: provide no stubs, but mention any "interesting" interface aspects in the HINT.md file (which gets merged into the README.md for the exercise).
+> - Exercises 21+: provide no stubs, but mention any "interesting" interface aspects in the HINTS.md file (which gets merged into the README.md for the exercise).
 
 References: [[1](https://github.com/exercism/java/issues/178)]
 
@@ -54,7 +54,7 @@ References: [[1](https://github.com/exercism/java/issues/101#issuecomment-249349
 
 ### Multiple file submissions
 
-> The first exercise in the track whose test suite mandates multiple solution files should be accompanied by a HINT.md file reminding the practitioner that the CLI supports multiple file submissions.
+> The first exercise in the track whose test suite mandates multiple solution files should be accompanied by a HINTS.md file reminding the practitioner that the CLI supports multiple file submissions.
 
 References: [[1](https://github.com/exercism/java/issues/365#issuecomment-292533120)]
 

data/tracks/java/README.md

@@ -1,10 +1,10 @@
-# java [![Build Status](https://travis-ci.org/exercism/java.svg?branch=master)](https://travis-ci.org/exercism/java) [![Join the chat at https://gitter.im/exercism/xjava](https://badges.gitter.im/exercism/java.svg)](https://gitter.im/exercism/xjava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# java [![Build Status](https://travis-ci.org/exercism/java.svg?branch=master)](https://travis-ci.org/exercism/java) [![Join the chat at https://gitter.im/exercism/xjava](https://badges.gitter.im/exercism/java.svg)](https://gitter.im/exercism/java?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Source for Exercism Exercises in Java.
 
 ## Contributing Guide
 
-For general information about how to contribute to Exercism, please refer to the [Contributing Guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data).
+For general information about how to contribute to Exercism, please refer to the [Contributing Guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks).
 
 ## Table of Contents
 
@@ -21,7 +21,7 @@ For general information about how to contribute to Exercism, please refer to the
 
 This guide covers contributing to the Java track.  If you are new, this guide is for you.
 
-If, at any point, you're having any trouble, pop in the [Gitter exercism/dev room](https://gitter.im/exercism/dev) for help.
+If, at any point, you're having any trouble, pop in the [Gitter exercism/java room](https://gitter.im/exercism/java) or the [Gitter exercism/dev room](https://gitter.im/exercism/dev) for help.
 
 ## Contributing With Minimal Setup
 
@@ -34,7 +34,7 @@ To submit a fix for an existing exercise or port an exercise to Java with the le
    (see [exercism.io: Installing Java](http://exercism.io/languages/java/installing))
 -  **Setup a branch on a fork of [exercism/java](https://github.com/exercism/java) on your computer.**
 
-   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with [Exercism Contributing Guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#git-basics)) to:
+   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with the [Git Basics doc](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md)) to:
    * "fork" a repository on GitHub;
    - install `git`;
    - "clone" a copy of your fork;
@@ -52,14 +52,14 @@ To submit a fix for an existing exercise or port an exercise to Java with the le
    $ git push
    ```
 
-   [Exercism Contributing Guide :: Commit Messages](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#commit-messages) provides practical advice on crafting meaningful commit messages.
+   The Git Basics doc has a section on [commit messages](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md#commit-messages) that provides practical advice on crafting meaningful commit messages.
 -  **Verify that your work passes all tests.**  When you create a pull request (PR), GitHub triggers a build on Travis CI.  Your PR will not be merged unless those tests pass.
 
 ## Getting Familiar With the Codebase
 
 There are two objectives to the design of this build:
 
-1. when a problem is built from within the `exercism/java` repo, the tests run against the "example" code (i.e. when you, the contributor, are developing the exercise);
+1. when a problem is built from within the `exercism/java` repo (i.e. when you, the contributor, are developing the exercise), the tests run against the "example" code;
 2. when a problem is built outside the `exercism/java` repo (when a participant is solving the exercise), the tests run against the "main" code.
 
 This repo is a multi-project gradle build.
@@ -68,15 +68,15 @@ This repo is a multi-project gradle build.
 
 This is the top-level module, contained in the `exercises` directory.  It is a container for the problem sub-modules.
 
-  * it's `build.gradle` points the "main" sourceset to the example code.
-  * it's `settings.gradle` names each of the subprojects, one for each problem in the set.
+  * its `build.gradle` points the "main" sourceset to the example code.
+  * its `settings.gradle` names each of the subprojects, one for each problem in the set.
 
 ### The Problem Submodules
 
 The `exercises` subdirectory contains all of the problem submodules.
 Each problem/submodule is a subdirectory of the same name as its slug.
 
-  * it's `build.gradle` names dependencies required to work that problem.
+  * its `build.gradle` names dependencies required to work that problem.
 
 Each problem/submodule has three source sets:
 

data/tracks/java/config.json

@@ -11,6 +11,13 @@
 
       ]
     },
+    {
+      "slug": "two-fer",
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
     {
       "slug": "rna-transcription",
       "difficulty": 2,
@@ -284,6 +291,18 @@
 
       ]
     },
+    {
+      "slug": "transpose",
+      "difficulty": 6,
+      "topics": [
+
+      ]
+    },
+    {
+      "slug": "food-chain",
+      "difficulty": 6,
+      "topics": []
+    },
     {
       "slug": "beer-song",
       "difficulty": 6,
@@ -354,6 +373,13 @@
 
       ]
     },
+    {
+    	"slug": "bank-account",
+    	"difficulty": 6,
+    	"topics": [
+
+    	]
+    },
     {
       "slug": "anagram",
       "difficulty": 7,
@@ -403,6 +429,15 @@
 
       ]
     },
+    {
+      "slug": "poker",
+      "difficulty": 7,
+      "topics": [
+        "Parsing",
+        "Sorting",
+        "Games"
+      ]
+    },
     {
       "slug": "clock",
       "difficulty": 7,
@@ -460,15 +495,15 @@
       ]
     },
     {
-      "slug": "custom-set",
-      "difficulty": 10,
+      "slug": "list-ops",
+      "difficulty": 9,
       "topics": [
-
+      
       ]
     },
     {
-      "slug": "list-ops",
-      "difficulty": 1,
+      "slug": "custom-set",
+      "difficulty": 10,
       "topics": [
 
       ]

data/tracks/java/docs/ABOUT.md

@@ -16,7 +16,7 @@ The primary goals kept in mind during the making of the language were:
 
 The language derives much of its syntax from C and C++, but it has fewer low-level facilities than either of them.
 
-## Why Learn JAVA?
+## Why Learn Java?
 
 - JAVA IS EVERYWHERE. It is one of the most sought after programming languages. It is a standard for enterprise software, web-based content, games and mobile apps, as well as the [Android operating system](https://developer.android.com/index.html). 
 

data/tracks/java/docs/MAINTAINING.md

@@ -16,7 +16,7 @@ As a maintainer, you have write access to several repositories.  "write access"
 
 ### Exercism-wide
 
-- [x-common](https://github.com/exercism/x-common) — the library of canonical exercises.
+- [problem-specifications](https://github.com/exercism/problem-specifications) — the library of canonical exercises.
 - [discussions](https://github.com/exercism/discussions) — the place where project-wide conversations happen. 
   [issues sorted by most recently updated.](https://github.com/exercism/discussions/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
 - [docs](https://github.com/exercism/docs) - the place to find project-wide documentation.

data/tracks/java/exercises/bank-account/HINTS.md

@@ -0,0 +1,11 @@
+This exercise introduces [concurrency](https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html). 
+To pass the last test you might find the 
+[`synchronized` keyword or locks](https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html) useful.
+
+Problems arising from running code concurrently are often intermittent because they depend on the order the code is
+executed. Therefore the last test runs many [threads](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html) 
+several times to increase the chances of catching a bug. That means this test should fail if your implementation is not
+[thread safe](https://en.wikipedia.org/wiki/Thread_safety), but there is a chance it will pass just because there was 
+no concurrent modification attempt. It is unlikely that this will occur several times 
+in a row since the order the code is executed should vary every time you run the test. So if you run the last test a 
+couple of times and it passes every time then you can be reasonably sure that your implementation is correct.

data/tracks/java/exercises/bank-account/build.gradle

@@ -0,0 +1,18 @@
+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"]
+    }
+}

data/tracks/java/exercises/bank-account/src/example/java/BankAccount.java

@@ -0,0 +1,53 @@
+class BankAccount {
+    private int balance = 0;
+    private boolean isClosed = true;
+
+    void open() {
+        isClosed = false;
+    }
+
+    void close() {
+        isClosed = true;
+    }
+
+    synchronized int getBalance() throws BankAccountActionInvalidException {
+        checkIfClosed();
+        return balance;
+    }
+
+    synchronized void deposit(int amount) throws BankAccountActionInvalidException {
+        checkIfClosed();
+        checkIfValidAmount(amount);
+
+        balance += amount;
+    }
+
+    synchronized void withdraw(int amount) throws BankAccountActionInvalidException {
+        checkIfClosed();
+        checkIfValidAmount(amount);
+        checkIfEnoughMoneyInAccount(amount);
+
+        balance -= amount;
+    }
+
+    private void checkIfValidAmount(int amount) throws BankAccountActionInvalidException {
+        if (amount < 0) {
+            throw new BankAccountActionInvalidException("Cannot deposit or withdraw negative amount");
+        }
+    }
+
+    private void checkIfEnoughMoneyInAccount(int amount) throws BankAccountActionInvalidException {
+        if (balance == 0) {
+            throw new BankAccountActionInvalidException("Cannot withdraw money from an empty account");
+        }
+        if (balance - amount < 0) {
+            throw new BankAccountActionInvalidException("Cannot withdraw more money than is currently in the account");
+        }
+    }
+
+    private void checkIfClosed() throws BankAccountActionInvalidException {
+        if (isClosed) {
+            throw new BankAccountActionInvalidException("Account closed");
+        }
+    }
+}

data/tracks/java/exercises/bank-account/src/example/java/BankAccountActionInvalidException.java

@@ -0,0 +1,6 @@
+class BankAccountActionInvalidException extends Exception {
+
+    BankAccountActionInvalidException(String message) {
+        super(message);
+    }
+}

data/tracks/java/exercises/bank-account/src/main/java/BankAccountActionInvalidException.java

@@ -0,0 +1,6 @@
+class BankAccountActionInvalidException extends Exception {
+
+    BankAccountActionInvalidException(String message) {
+        super(message);
+    }
+}

data/tracks/java/exercises/bank-account/src/test/java/BankAccountTest.java

@@ -0,0 +1,201 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class BankAccountTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+    private BankAccount bankAccount;
+
+    @Before
+    public void setup() {
+        bankAccount = new BankAccount();
+    }
+
+    @Test
+    public void newlyOpenedAccountHasEmptyBalance() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        assertEquals(0, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canDepositMoney() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        bankAccount.deposit(10);
+
+        assertEquals(10, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canDepositMoneySequentially() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        bankAccount.deposit(5);
+        bankAccount.deposit(23);
+
+        assertEquals(28, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canWithdrawMoney() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(10);
+
+        bankAccount.withdraw(5);
+
+        assertEquals(5, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canWithdrawMoneySequentially() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(23);
+
+        bankAccount.withdraw(10);
+        bankAccount.withdraw(13);
+
+        assertEquals(0, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoneyFromEmptyAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot withdraw money from an empty account");
+
+        bankAccount.withdraw(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoreMoneyThanYouHave() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(6);
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot withdraw more money than is currently in the account");
+
+        bankAccount.withdraw(7);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotDepositNegativeAmount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot deposit or withdraw negative amount");
+
+        bankAccount.deposit(-1);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawNegativeAmount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(105);
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot deposit or withdraw negative amount");
+
+        bankAccount.withdraw(-5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotGetBalanceOfClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(10);
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.getBalance();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotDepositMoneyIntoClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.deposit(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoneyFromClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(20);
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.withdraw(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void bankAccountIsClosedBeforeItIsOpened() throws BankAccountActionInvalidException {
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.getBalance();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canAdjustBalanceConcurrently() throws BankAccountActionInvalidException, InterruptedException {
+        bankAccount.open();
+        bankAccount.deposit(1000);
+
+        for (int i = 0; i < 10; i++) {
+            adjustBalanceConcurrently();
+        }
+    }
+
+    private void adjustBalanceConcurrently() throws BankAccountActionInvalidException, InterruptedException {
+        Random random = new Random();
+
+        Thread[] threads = new Thread[1000];
+        for (int i = 0; i < 1000; i++) {
+            threads[i] = new Thread(() -> {
+                try {
+                    bankAccount.deposit(5);
+                    Thread.sleep(random.nextInt(10));
+                    bankAccount.withdraw(5);
+                } catch (BankAccountActionInvalidException e) {
+                    fail("Exception should not be thrown: " + e.getMessage());
+                } catch (InterruptedException ignored) {
+                }
+            });
+            threads[i].start();
+        }
+
+        for (Thread thread : threads) {
+            thread.join();
+        }
+
+        assertEquals(1000, bankAccount.getBalance());
+    }
+}