retrofit2.mock.MockRetrofitIOException: Failure triggered by MockRetrofit's NetworkBehavior

/**
 * A simple emulation of the behavior of network calls.
 * <p>
 * This class models three properties of a network:
 * <ul>
 * <li>Delay – the time it takes before a response is received (successful or otherwise).</li>
 * <li>Variance – the amount of fluctuation of the delay to be faster or slower.</li>
 * <li>Failure - the percentage of operations which fail (such as {@link IOException}).</li>
 * </ul>
 * Behavior can be applied to a Retrofit interface with {@link MockRetrofit}. Behavior can also
 * be applied elsewhere using {@link #calculateDelay(TimeUnit)} and {@link #calculateIsFailure()}.
 * <p>
 * By default, instances of this class will use a 2 second delay with 40% variance. Failures
 * will occur 3% of the time. HTTP errors will occur 0% of the time.
 */
public final class NetworkBehavior {
  private static final int DEFAULT_DELAY_MS = 2000; // Network calls will take 2 seconds.
  private static final int DEFAULT_VARIANCE_PERCENT = 40; // Network delay varies by ±40%.
  private static final int DEFAULT_FAILURE_PERCENT = 3; // 3% of network calls will fail.
  private static final int DEFAULT_ERROR_PERCENT = 0; // 0% of network calls will return errors.
  
  
  
  ....// Some more code 

  /** Set the percentage of calls to {@link #calculateIsFailure()} that return {@code true}. */
  public void setFailurePercent(int failurePercent) {
    checkPercentageValidity(failurePercent, "Failure percentage must be between 0 and 100.");
    this.failurePercent = failurePercent;
  }
  
  /**
   * Randomly determine whether this call should result in a network failure in accordance with
   * configured behavior. When true, {@link #failureException()} should be thrown.
   */
  public boolean calculateIsFailure() {
    return random.nextInt(100) < failurePercent;
  }
  
  private static void checkPercentageValidity(int percentage, String message) {
    if (percentage < 0 || percentage > 100) {
      throw new IllegalArgumentException(message);
    }
  }

/** @BenHenning Please go below near onRun() method, as we are not interested in this. */

final class BehaviorCall<T> implements Call<T> {
  final NetworkBehavior behavior;
  final ExecutorService backgroundExecutor;
  final Call<T> delegate;

  private volatile Future<?> task;
  volatile boolean canceled;
  @GuardedBy("this")
  private boolean executed;

  BehaviorCall(NetworkBehavior behavior, ExecutorService backgroundExecutor, Call<T> delegate) {
    this.behavior = behavior;
    this.backgroundExecutor = backgroundExecutor;
    this.delegate = delegate;
  }

  @SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.
  @Override public Call<T> clone() {
    return new BehaviorCall<>(behavior, backgroundExecutor, delegate.clone());
  }

  @Override public Request request() {
    return delegate.request();
  }

  @SuppressWarnings("ConstantConditions") // Guarding public API nullability.
  @Override public void enqueue(final Callback<T> callback) {
    if (callback == null) throw new NullPointerException("callback == null");

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed");
      executed = true;
    }
    task = backgroundExecutor.submit(new Runnable() {
      boolean delaySleep() {
        long sleepMs = behavior.calculateDelay(MILLISECONDS);
        if (sleepMs > 0) {
          try {
            Thread.sleep(sleepMs);
          } catch (InterruptedException e) {
            callback.onFailure(BehaviorCall.this, new IOException("canceled"));
            return false;
          }
        }
        return true;
      }
      
      
      /** @BenHenning We are interested here. */
      
      @Override public void run() {
        if (canceled) {
          callback.onFailure(BehaviorCall.this, new IOException("canceled"));
        } else if (behavior.calculateIsFailure()) {
          if (delaySleep()) {
            callback.onFailure(BehaviorCall.this, behavior.failureException());
          }
        } else if (behavior.calculateIsError()) {
          if (delaySleep()) {
            //noinspection unchecked An error response has no body.
            callback.onResponse(BehaviorCall.this, (Response<T>) behavior.createErrorResponse());
          }
        } else {
          delegate.enqueue(new Callback<T>() {
            @Override public void onResponse(Call<T> call, Response<T> response) {
              if (delaySleep()) {
                callback.onResponse(call, response);
              }
            }

            @Override public void onFailure(Call<T> call, Throwable t) {
              if (delaySleep()) {
                callback.onFailure(call, t);
              }
            }
          });
        }
      }
    });
  }