Intermittent failure was due to Thread.sleep in the code. While performing unit test cases there was race condition between two threads, so it was not guaranteed to work every time. Used an interface DelayProvider for simulating delay, and while unit testing fake delay provider is used that eradicates the use of Threads in unit test cases, which is not a good practice.

ambassador/src/main/java/com/iluwatar/ambassador/RemoteService.java

@@ -22,7 +22,6 @@
  */
 package com.iluwatar.ambassador;
 
-import com.iluwatar.ambassador.util.RandomProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -32,10 +31,9 @@ import static java.lang.Thread.sleep;
  * A remote legacy application represented by a Singleton implementation.
  */
 public class RemoteService implements RemoteServiceInterface {
-  static final int THRESHOLD = 200;
+
   private static final Logger LOGGER = LoggerFactory.getLogger(RemoteService.class);
   private static RemoteService service = null;
-  private final RandomProvider randomProvider;
 
   static synchronized RemoteService getRemoteService() {
     if (service == null) {
@@ -44,33 +42,24 @@ public class RemoteService implements RemoteServiceInterface {
     return service;
   }
 
-  private RemoteService() {
-    this(Math::random);
-  }
+  private RemoteService() {}
 
-  /**
-   * This constuctor is used for testing purposes only.
-   */
-  RemoteService(RandomProvider randomProvider) {
-    this.randomProvider = randomProvider;
-  }
   /**
    * Remote function takes a value and multiplies it by 10 taking a random amount of time.
    * Will sometimes return -1. This imitates connectivity issues a client might have to account for.
    * @param value integer value to be multiplied.
-   * @return if waitTime is less than {@link RemoteService#THRESHOLD}, it returns value * 10,
-   *     otherwise {@link RemoteServiceInterface#FAILURE}.
+   * @return if waitTime is more than 200ms, it returns value * 10, otherwise -1.
    */
   @Override
   public long doRemoteFunction(int value) {
 
-    long waitTime = (long) Math.floor(randomProvider.random() * 1000);
+    long waitTime = (long) Math.floor(Math.random() * 1000);
 
     try {
       sleep(waitTime);
     } catch (InterruptedException e) {
       LOGGER.error("Thread sleep state interrupted", e);
     }
-    return waitTime <= THRESHOLD ? value * 10 : FAILURE;
+    return waitTime >= 200 ? value * 10 : -1;
   }
 }

ambassador/src/main/java/com/iluwatar/ambassador/RemoteServiceInterface.java

@@ -26,7 +26,6 @@ package com.iluwatar.ambassador;
  * Interface shared by ({@link RemoteService}) and ({@link ServiceAmbassador}).
  */
 interface RemoteServiceInterface {
-  int FAILURE = -1;
-
+    
   long doRemoteFunction(int value) throws Exception;
 }

ambassador/src/main/java/com/iluwatar/ambassador/ServiceAmbassador.java

@@ -59,15 +59,15 @@ public class ServiceAmbassador implements RemoteServiceInterface {
   private long safeCall(int value) {
 
     int retries = 0;
-    long result = FAILURE;
+    long result = -1;
 
     for (int i = 0; i < RETRIES; i++) {
 
       if (retries >= RETRIES) {
-        return FAILURE;
+        return -1;
       }
 
-      if ((result = checkLatency(value)) == FAILURE) {
+      if ((result = checkLatency(value)) == -1) {
         LOGGER.info("Failed to reach remote: (" + (i + 1) + ")");
         retries++;
         try {

ambassador/src/main/java/com/iluwatar/ambassador/util/RandomProvider.java

@@ -1,8 +0,0 @@
-package com.iluwatar.ambassador.util;
-
-/**
- * An interface for randomness. Useful for testing purposes.
- */
-public interface RandomProvider {
-  double random();
-}

ambassador/src/test/java/com/iluwatar/ambassador/ClientTest.java

@@ -24,8 +24,6 @@ package com.iluwatar.ambassador;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 /**
  * Test for {@link Client}
  */
@@ -37,6 +35,6 @@ public class ClientTest {
     Client client = new Client();
     long result = client.useService(10);
 
-    assertTrue(result == 100 || result == RemoteService.FAILURE);
+    assert result == 100 || result == -1;
   }
 }

ambassador/src/test/java/com/iluwatar/ambassador/RemoteServiceTest.java

@@ -22,43 +22,16 @@
  */
 package com.iluwatar.ambassador;
 
-import com.iluwatar.ambassador.util.RandomProvider;
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 /**
  * Test for {@link RemoteService}
  */
 public class RemoteServiceTest {
 
   @Test
-  public void testFailedCall() {
-    RemoteService remoteService = new RemoteService(
-        new StaticRandomProvider(0.21));
-    long result = remoteService.doRemoteFunction(10);
-    assertEquals(RemoteServiceInterface.FAILURE, result);
-  }
-
-  @Test
-  public void testSuccessfulCall() {
-    RemoteService remoteService = new RemoteService(
-        new StaticRandomProvider(0.2));
-    long result = remoteService.doRemoteFunction(10);
-    assertEquals(100, result);
-  }
-
-  private class StaticRandomProvider implements RandomProvider {
-    private double value;
-
-    StaticRandomProvider(double value) {
-      this.value = value;
-    }
-
-    @Override
-    public double random() {
-      return value;
-    }
+  public void test() {
+    long result = RemoteService.getRemoteService().doRemoteFunction(10);
+    assert result == 100 || result == -1;
   }
 }

ambassador/src/test/java/com/iluwatar/ambassador/ServiceAmbassadorTest.java

@@ -24,8 +24,6 @@ package com.iluwatar.ambassador;
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 /**
  * Test for {@link ServiceAmbassador}
  */
@@ -34,6 +32,6 @@ public class ServiceAmbassadorTest {
   @Test
   public void test() {
     long result = new ServiceAmbassador().doRemoteFunction(10);
-    assertTrue(result == 100 || result == RemoteServiceInterface.FAILURE);
+    assert result == 100 || result == -1;
   }
 }

balking/src/main/java/com/iluwatar/balking/DelayProvider.java

@@ -0,0 +1,10 @@
+package com.iluwatar.balking;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An interface to simulate delay while executing some work.
+ */
+public interface DelayProvider {
+  void executeAfterDelay(long interval, TimeUnit timeUnit, Runnable task);
+}

balking/src/main/java/com/iluwatar/balking/WashingMachine.java

@@ -25,17 +25,38 @@ package com.iluwatar.balking;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.concurrent.TimeUnit;
+
 /**
  * Washing machine class
  */
 public class WashingMachine {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(WashingMachine.class);
-
+  private final DelayProvider delayProvider;
   private WashingMachineState washingMachineState;
 
+  /**
+   * Creates a new instance of WashingMachine
+   */
   public WashingMachine() {
-    washingMachineState = WashingMachineState.ENABLED;
+    this((interval, timeUnit, task) -> {
+      try {
+        Thread.sleep(timeUnit.toMillis(interval));
+      } catch (InterruptedException ie) {
+        ie.printStackTrace();
+      }
+      task.run();
+    });
+  }
+
+  /**
+   * Creates a new instance of WashingMachine using provided delayProvider. This constructor is used only for
+   * unit testing purposes.
+   */
+  public WashingMachine(DelayProvider delayProvider) {
+    this.delayProvider = delayProvider;
+    this.washingMachineState = WashingMachineState.ENABLED;
   }
 
   public WashingMachineState getWashingMachineState() {
@@ -56,12 +77,8 @@ public class WashingMachine {
       washingMachineState = WashingMachineState.WASHING;
     }
     LOGGER.info("{}: Doing the washing", Thread.currentThread().getName());
-    try {
-      Thread.sleep(50);
-    } catch (InterruptedException ie) {
-      ie.printStackTrace();
-    }
-    endOfWashing();
+
+    this.delayProvider.executeAfterDelay(50, TimeUnit.MILLISECONDS, this::endOfWashing);
   }
 
   /**

balking/src/test/java/com/iluwatar/balking/WashingMachineTest.java

@@ -22,11 +22,8 @@
  */
 package com.iluwatar.balking;
 
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -36,32 +33,39 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
  */
 public class WashingMachineTest {
 
-  private volatile WashingMachineState machineStateGlobal;
+  private FakeDelayProvider fakeDelayProvider = new FakeDelayProvider();
 
-  @Disabled
   @Test
-  public void wash() throws Exception {
-    WashingMachine washingMachine = new WashingMachine();
-    ExecutorService executorService = Executors.newFixedThreadPool(2);
-    executorService.execute(washingMachine::wash);
-    executorService.execute(() -> {
-      washingMachine.wash();
-      machineStateGlobal = washingMachine.getWashingMachineState();
-    });
-    executorService.shutdown();
-    try {
-      executorService.awaitTermination(10, TimeUnit.SECONDS);
-    } catch (InterruptedException ie) {
-      ie.printStackTrace();
-    }
+  public void wash() {
+    WashingMachine washingMachine = new WashingMachine(fakeDelayProvider);
+
+    washingMachine.wash();
+    washingMachine.wash();
+
+    WashingMachineState machineStateGlobal = washingMachine.getWashingMachineState();
+
+    fakeDelayProvider.task.run();
+
+    // washing machine remains in washing state
     assertEquals(WashingMachineState.WASHING, machineStateGlobal);
+
+    // washing machine goes back to enabled state
+    assertEquals(WashingMachineState.ENABLED, washingMachine.getWashingMachineState());
   }
 
   @Test
-  public void endOfWashing() throws Exception {
+  public void endOfWashing() {
     WashingMachine washingMachine = new WashingMachine();
     washingMachine.wash();
     assertEquals(WashingMachineState.ENABLED, washingMachine.getWashingMachineState());
   }
 
+  private class FakeDelayProvider implements DelayProvider {
+    private Runnable task;
+
+    @Override
+    public void executeAfterDelay(long interval, TimeUnit timeUnit, Runnable task) {
+      this.task = task;
+    }
+  }
 }