this( new URL( null, url, Handler.SMB_HANDLER ), auth );
        if ((shareAccess & ~(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)) != 0) {
            throw new RuntimeException( "Illegal shareAccess parameter" );
        }
        this.shareAccess = shareAccess;
    }
/**
 * Constructs an SmbFile representing a resource on an SMB network such

    assertThrows(
        RuntimeException.class,
        () -> SerializableTester.reserialize(TypeToken.of(new TypeCapture<B>() {}.capture())));
  }

  public <A> void testSerializable_typeVariableNotSupported() {
    assertThrows(RuntimeException.class, () -> new ITryToSerializeMyTypeVariable<String>().go());
  }

    assertThrows(
        RuntimeException.class,
        () -> SerializableTester.reserialize(TypeToken.of(new TypeCapture<B>() {}.capture())));
  }

  public <A> void testSerializable_typeVariableNotSupported() {
    assertThrows(RuntimeException.class, () -> new ITryToSerializeMyTypeVariable<String>().go());
  }

        if (exception == null) {
          exception = e;
        } else {
          exception.addSuppressed(e);
        }
      }
    }
    if (exception != null) {
      // Normally this is a RuntimeException that doesn't need sneakyThrow.
      // But theoretically we could see sneaky checked exception
      sneakyThrow(exception);
    }
  }

  /** Throws an undeclared checked exception. */

          sink.flush()
          Thread.sleep(100)
          i += chunk.size
        }
      } catch (e: IOException) {
        ioe = e
      } catch (e: InterruptedException) {
        throw RuntimeException(e)
      }
    }
  }

  @Test
  fun requestBodyMultipleFailuresReportedOnlyOnce() {
    val requestBody: RequestBody =
      object : RequestBody() {

  @Test
  fun unexpectedExceptionSync() {
    client =
      client.newBuilder()
        .dns { hostname: String? -> throw RuntimeException("boom!") }
        .build()
    server.enqueue(MockResponse())
    assertFailsWith<RuntimeException> {
      getResponse(newRequest("/"))
    }.also { expected ->
      assertThat(expected.message).isEqualTo("boom!")
    }
  }

  @Test

      } catch (ExecutionException ee) {
        Throwable cause = ee.getCause();
        if (cause instanceof Error) {
          throw new ExecutionError((Error) cause);
        } else if (cause instanceof RuntimeException) {
          throw new UncheckedExecutionException(cause);
        }
        throw ee;
      } finally {
        postReadCleanup();
      }
    }

    @CheckForNull

               * `AutoCloseable`.
               *
               * In guava-android, the only kinds of Exception that may be thrown are
               * RuntimeException and IOException because `closeable` has type `Closeable`—except
               * that we have to account for sneaky checked exception.
               */
              restoreInterruptIfIsInterruptedException(e);

            return (T) createResp.getNextResponse();
        }
        catch (
            CIFSException |
            RuntimeException e ) {
            try {
                // make sure that the handle is closed when one of the requests fails
                Smb2CreateResponse createResp = cr.getResponse();

synchronized class Launch$$anonfun$1 extends scala.runtime.AbstractFunction2 implements scala.Serializable { public void Launch$$anonfun$1(Launch); } xsbt/boot/BootException.class package xsbt.boot; public synchronized class BootException extends RuntimeException { private final String toString; public String toString(); public void BootException(String); } xsbt/boot/Copy$$anonfun$apply$2$$anonfun$apply$3.class package xsbt.boot; public final synchronized class Copy$$anonfun$apply$2$$anonfun$apply$3 extends...