}
  }

  private static Short[] concat(Short[] left, Short[] right) {
    Short[] result = new Short[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);
    return result;
  }

  public abstract static class TestShortListGenerator implements TestListGenerator<Short> {
    @Override

    }
  }

  private static Long[] concat(Long[] left, Long[] right) {
    Long[] result = new Long[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);
    return result;
  }

  public abstract static class TestLongListGenerator implements TestListGenerator<Long> {
    @Override

        if ( bc > 0 ) {
            this.errorData = new byte[bc];
            System.arraycopy(buffer, bufferIndex, this.errorData, 0, bc);
            bufferIndex += bc;
        }
        return bufferIndex - start;
    }


    protected int writeHeaderWireFormat ( byte[] dst, int dstIndex ) {
        System.arraycopy(SMBUtil.SMB2_HEADER, 0, dst, dstIndex, SMBUtil.SMB2_HEADER.length);

     */
    public static SID CREATOR_OWNER = null;

    /**
     * Well known SID: SYSTEM
     */
    public static SID SYSTEM = null;

    static {
        try {
            EVERYONE = new SID("S-1-1-0");
            CREATOR_OWNER = new SID("S-1-3-0");
            SYSTEM = new SID("S-1-5-18");
        }
        catch ( SmbException se ) {

        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

  public static void main(String... args) throws Exception {
    new PostFile().run();
  }

        return this.len;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        System.arraycopy(this.bytes, this.off, dst, dstIndex, this.len);
        return this.len;
    }

    String secondLine = "\\s*at " + ThrowablesTest.class.getName() + "\\..*";
    String moreLines = "(?:.*" + System.lineSeparator() + "?)*";
    String expected =
        firstLine + System.lineSeparator() + secondLine + System.lineSeparator() + moreLines;
    assertThat(getStackTraceAsString(e)).matches(expected);
  }

  public void testGetCausalChain() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("org.gradle.test-retry")
}

if (System.getenv().containsKey("CI")) {
    tasks.withType<Test>().configureEach {
        retry {
            maxRetries.set(2)
        }
    }

    assertEquals(oldName, Thread.currentThread().getName());
  }

  @J2ktIncompatible
  @GwtIncompatible // threads

  public void testRenaming_noPermissions() throws Exception {
    System.setSecurityManager(
        new SecurityManager() {
          @Override
          public void checkAccess(Thread t) {
            throw new SecurityException();
          }

          @Override

  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val call = chain.call()
    val cacheCandidate = cache?.get(chain.request().requestForCache())

    val now = System.currentTimeMillis()

    val strategy = CacheStrategy.Factory(now, chain.request(), cacheCandidate).compute()
    val networkRequest = strategy.networkRequest
    val cacheResponse = strategy.cacheResponse