BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(dest))) {
            final byte[] buf = new byte[1024];
            int length;
            while (-1 < (length = in.read(buf))) {
                out.write(buf, 0, length);
                out.flush();
            }
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**

  private HashTestUtils() {}

  /** Converts a string, which should contain only ascii-representable characters, to a byte[]. */
  static byte[] ascii(String string) {
    byte[] bytes = new byte[string.length()];
    for (int i = 0; i < string.length(); i++) {
      bytes[i] = (byte) string.charAt(i);
    }
    return bytes;
  }

  interface HashFn {
    byte[] hash(byte[] input, int seed);
  }

  private static boolean isLongTimeUnitBased(Method method) {
    Class<?>[] parameterTypes = method.getParameterTypes();
    return parameterTypes.length >= 2
        && parameterTypes[parameterTypes.length - 2] == long.class
        && parameterTypes[parameterTypes.length - 1] == TimeUnit.class;
  }

  /** Determines whether the given method takes a Duration as its last parameter. */

      val contentLength = body.contentLength()
      if (contentLength != -1L) {
        requestBuilder.header("Content-Length", contentLength.toString())
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")
        requestBuilder.removeHeader("Content-Length")
      }
    }

    if (userRequest.header("Host") == null) {

		t.Fatalf("Failed to find address, got error %v, length: %v", err, len(addresses2))
	}

	if DB.Model(&person).Association("Addresses").Count() != 1 {
		t.Fatalf("Should found one address")
	}

	var addresses3 []Address
	if err := DB.Unscoped().Model(&person).Association("Addresses").Find(&addresses3); err != nil || len(addresses3) != 2 {
		t.Fatalf("Failed to find address, got error %v, length: %v", err, len(addresses3))
	}

@ElementTypesAreNonnullByDefault
public interface TestBiMapGenerator<K extends @Nullable Object, V extends @Nullable Object>
    extends TestContainerGenerator<BiMap<K, V>, Entry<K, V>> {
  K[] createKeyArray(int length);

  V[] createValueArray(int length);

    @Override
    public String normalize(final String text, final String field, final String... langs) {
        final char[] chars = new char[text.length()];
        for (int i = 0; i < chars.length; i++) {
            final char c = text.charAt(i);
            if (c >= 'ａ' && c <= 'ｚ') {
                chars[i] = (char) (c - 'ａ' + 'a');
            } else if (c >= 'Ａ' && c <= 'Ｚ') {

    public void test_Get() {
        Curl.get("https://www.codelibs.org/").execute(response -> {
            final String content = response.getContentAsString();
            logger.info(content);
            assertTrue(content.length() > 0);
        }, e -> {
            logger.log(Level.SEVERE, "error", e);
            fail();
        });
    }

    /*
    @Test
    public void test_Get_ssl() throws Exception {

 * Benchmark for {@code LocalCache.Segment.removeEntryFromChain}.
 *
 * @author Charles Fry
 */
@SuppressWarnings("CheckReturnValue")
public class ChainBenchmark {

  @Param({"1", "2", "3", "4", "5", "6"})
  int length;

  private Segment<Object, Object> segment;
  private ReferenceEntry<Object, Object> head;
  private @Nullable ReferenceEntry<Object, Object> chain;

  @SuppressWarnings("GuardedBy")
  @BeforeExperiment

        final int size = windowSize / searchers.length;
        if (logger.isDebugEnabled()) {
            logger.debug("The searcher window size is {} and a rank constant is {}.", size, rankConstant);
        }
        final List<Future<SearchResult>> resultList = new ArrayList<>();
        for (int i = 0; i < searchers.length; i++) {