}

        @Test
        @DisplayName("Should throw configured exception on decode")
        void testConfiguredExceptionOnDecode() {
            testResponse.setThrowOnDecode(true);

            assertThrows(SMBProtocolDecodingException.class, () -> testResponse.decode(testBuffer, 0, 10),
                    "Should throw configured exception");
        }

        @ParameterizedTest

    }

    private static ByteArrayOutputStream connectStream(InputStream forkedProcessOutput, CountDownLatch latch) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os, true);
        new Thread(() -> {
            try {
                BufferedReader reader = new BufferedReader(new InputStreamReader(forkedProcessOutput, UTF_8));
                String line;

      CopyOnWriteArraySet<Subscriber> currentSubscribers = subscribers.get(eventType);
      if (currentSubscribers == null || !currentSubscribers.removeAll(listenerMethodsForType)) {
        // if removeAll returns true, all we really know is that at least one subscriber was
        // removed... however, barring something very strange we can assume that if at least one

  static final int SIZE = 20;

  /** Returns a new started daemon Thread running the given runnable. */
  final Thread newStartedThread(Runnable runnable) {
    Thread t = new Thread(runnable);
    t.setDaemon(true);
    t.start();
    return t;
  }

  /**
   * Waits for the specified time (in milliseconds) for the thread to terminate (using {@link

     */
    public static boolean getBoolean(final Properties props, final String key, boolean def) {
        final String b = props.getProperty(key);
        if (b != null) {
            def = b.toLowerCase().equals("true");
        }
        return def;
    }

    /**
     * Retrieve an array of <code>InetAddress</code> created from a property
     * value containing a <code>delim</code> separated list of host names and/or

                            results[index] = false; // Mark as failed if unexpected result
                            return;
                        }
                    }
                    results[index] = true; // Mark as successful
                });
                threads[i].start();
            }

            // Wait for all threads to complete
            for (Thread thread : threads) {

- github.com/karrick/godirwalk: [v1.17.0](https://github.com/karrick/godirwalk/tree/v1.17.0)
- github.com/libopenstorage/openstorage: [v1.0.0](https://github.com/libopenstorage/openstorage/tree/v1.0.0)
- github.com/moby/sys/atomicwriter: [v0.1.0](https://github.com/moby/sys/tree/atomicwriter/v0.1.0)
- github.com/mohae/deepcopy: [c48cc78](https://github.com/mohae/deepcopy/tree/c48cc78)

    val jsonBody =
      """
      |{
      |  "user": {
      |    "id": 123,
      |    "name": "Tim O'Reilly"
      |  },
      |  "roles": ["admin", "editor"],
      |  "active": true
      |}
      |
      """.trimMargin()

    val body = jsonBody.toRequestBody("application/json".toMediaType())

    val request =
      Request
        .Builder()

    volatile boolean stoppedCalled;
    final Set<Service> failedServices = Sets.newConcurrentHashSet();

    @Override
    public void healthy() {
      healthyCalled = true;
    }

    @Override
    public void stopped() {
      stoppedCalled = true;
    }

    @Override
    public void failure(Service service) {
      failedServices.add(service);
    }
  }

  private static boolean isWindows() {

        return this.resolveHashes;
    }

    /**
     * Mark this referral as intermediate (requires further resolution)
     */
    public void intermediate() {
        this.intermediate = true;
    }

    /**
     * @return the intermediate
     */
    @Override
    public boolean isIntermediate() {
        return this.intermediate;
    }

    @Override