@MethodSource("nameCases")
    @DisplayName("accept: name-based filter handles normal, empty, and null names")
    void accept_nameBasedFilter_handlesEdgeNames(String name, boolean expected) throws Exception {
        // Arrange: filter that accepts non-empty names ending with .txt
        SmbFileFilter filter = f -> {
            String n = f.getName();

    }
    val requestBody = (call.request().body as AsyncRequestBody?)!!.takeSink()
    assertFailsWith<IOException> {
      requestBody.writeUtf8("request body\n")
      requestBody.flush()
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("stream was reset: CANCEL")
    }
    body.awaitSuccess()
    assertThat(eventRecorder.recordedEventTypes()).containsExactly(
      CallStart::class,

      requestBuilder.url("ftp://hostname/path")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Expected URL scheme 'http' or 'https' but was 'ftp'")
    }
  }

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("http://localhost:65536/")
    }.also { expected ->

    String expected = begin + end;
    assertEquals(expected.charAt(0), joinedReader.read());
    CharStreams.skipFully(joinedReader, 1);
    assertEquals(expected.charAt(2), joinedReader.read());
    CharStreams.skipFully(joinedReader, 4);
    assertEquals(expected.charAt(7), joinedReader.read());
    CharStreams.skipFully(joinedReader, 1);
    assertEquals(expected.charAt(9), joinedReader.read());

	echo "BUG: MD5 checksum of object 'minio2/test-bucket/encrypted' doesn't match with source. Expected: '${src_obj1_md5}', Found: '${rep_obj1_md5}'"
	exit_1
fi
if [ "${src_obj2_md5}" != "${rep_obj2_md5}" ]; then
	echo "BUG: MD5 checksum of object 'minio2/test-bucket/defpartsize' doesn't match with source. Expected: '${src_obj2_md5}', Found: '${rep_obj2_md5}'"
	exit_1
fi
if [ "${src_obj3_md5}" != "${rep_obj3_md5}" ]; then

   * MultimapBuilder.hashKeys(expectedKeys).hashSetValues(expectedValuesPerKey).build()}, which
   * provides more control over the underlying data structure.
   *
   * @param expectedKeys the expected number of distinct keys
   * @param expectedValuesPerKey the expected average number of values per key
   * @throws IllegalArgumentException if {@code expectedKeys} or {@code expectedValuesPerKey} is
   *     negative
   */

    Map<Object, Object> expected = new LinkedHashMap<>();
    for (int i = 0; i < alternatingKeysAndValues.length; i += 2) {
      expected.put(alternatingKeysAndValues[i], alternatingKeysAndValues[i + 1]);
    }
    assertThat(map).containsExactlyEntriesIn(expected).inOrder();
  }

  private static class IntHolder implements Serializable {

// an operation, or provided to create a function.
// When executing an operation in an eager context, the expected number of
// outputs must be set beforehand with `TF_OutputListSetNumOutputs`.
typedef struct TF_OutputList TF_OutputList;
TF_OutputList* TF_NewOutputList();
void TF_DeleteOutputList(TF_OutputList* o);
// Prepare tracing to the expected number of output for an operation.

    try {
      Longs.concat(arrays);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  private static void assertByteArrayEquals(byte[] expected, byte[] actual) {
    assertWithMessage(
            "Expected: %s, but got: %s", Arrays.toString(expected), Arrays.toString(actual))
        .that(Arrays.equals(expected, actual))
        .isTrue();
  }

  public void testToByteArray() {

    val call1 = client.newCall(Request(server.url("/")))
    assertFailsWith<IOException> {
      call1.execute()
    }.also { expected ->
      when (expected) {
        is SocketTimeoutException, is SSLException -> {}

        else -> {
          throw expected
        }
      }
    }

    // The second call times out because it uses the same bad connection.