}

    // ////////////////////////////////////////////////////////////////
    // from String to OutputStream
    //
    /**
     * Copies a string to an output stream using the platform default encoding.
     * <p>
     * The output stream is not closed.
     * </p>
     *
     * @param in the string (must not be {@literal null})
     * @param out the output stream (must not be {@literal null})

	cli.Watcher = namespace.NewWatcher(cli.Watcher, cfg.PathPrefix)
	cli.Lease = namespace.NewLease(cli.Lease, cfg.PathPrefix)
	return cli, nil
}

func parseEndpoints(endpoints string) ([]string, bool, error) {
	etcdEndpoints := strings.Split(endpoints, config.ValueSeparator)

	var etcdSecure bool
	for _, endpoint := range etcdEndpoints {
		u, err := xnet.ParseHTTPURL(endpoint)
		if err != nil {

  private final HttpUrl baseUrl = HttpUrl.get("https://slack.com/api/");
  private final OkHttpClient httpClient;
  private final Moshi moshi;

  public final String clientId;
  public final String clientSecret;
  public final int port;

  public SlackApi(String clientId, String clientSecret, int port) {
    this.httpClient = new OkHttpClient.Builder()
        .build();
    this.moshi = new Moshi.Builder()

        public Optional<Packaging> lookup(String id) {
            return Optional.of(new Packaging() {
                @Override
                public String id() {
                    return id;
                }

                @Override
                public Type type() {
                    return null;
                }

                @Override
                public Map<String, PluginContainer> plugins() {

    }

    protected long toKB(long bytes) {
        return (bytes + 1023) / 1024;
    }

    private void println(String event, String message) {
        print(event, message);
        out.println();
    }

    private void print(String event, String message) {
        out.print("Aether Transfer - " + event);
        if (message != null) {
            out.print(": ");

        public Optional<Packaging> lookup(String id) {
            return Optional.of(new Packaging() {
                @Override
                public String id() {
                    return id;
                }

                @Override
                public Type type() {
                    return null;
                }

                @Override
                public Map<String, PluginContainer> plugins() {

     */
    public DcerpcException(final String msg) {
        super(msg);
    }

    /**
     * Constructs a DcerpcException with the specified message and root cause
     *
     * @param msg
     *            the error message
     * @param rootCause
     *            the underlying cause of this exception
     */
    public DcerpcException(final String msg, final Throwable rootCause) {

        final int expectedNt = 0xc0000002;
        Optional<Integer> actual = findNtStatus(dosErr);
        assertTrue(actual.isPresent(), String.format("Mapping for %08x should exist", dosErr));
        assertEquals(expectedNt, actual.get(), String.format("NTSTATUS for %08x should be %08x", dosErr, expectedNt));
    }

    @Test
    @DisplayName("Unknown DOS error code yields empty Optional")
    void testUnknownCode() {

    private Language language;

    private String moduleName;

    @Override
    public ProjectScope scope() {
        return (scope != null) ? scope : SourceRoot.super.scope();
    }

    @Override
    public Language language() {
        return (language != null) ? language : SourceRoot.super.language();
    }

    @Override
    public Optional<String> module() {
        return Optional.ofNullable(moduleName);

    if (failures.isNotEmpty()) {
      for (failure in failures) {
        println(failure)
      }
      throw failures.first()
    }
  }

  private fun testToAscii(
    input: String,
    output: String?,
    comment: String?,
  ) {
    val url = "https://$input/".toHttpUrlOrNull()
    assertThat(url?.host, name = comment ?: input).isEqualTo(output)
  }