/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

                    }
                }
            } catch (final Exception e) {
                running = false;
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to process an input stream.", e);
                }
            }
        }
    }

    public String getOutput() {
        final StringBuilder buf = new StringBuilder(100);

    assertThat(logs.map { it.type }).containsOnly(Log.INFO)
    assertThat(logs.map { it.msg }).containsExactly(
      "--> GET http://google.com/robots.txt",
      "<-- HTTP FAILED: java.net.UnknownHostException: shortcircuit",
    )
    // We should consider if these logs should retain Exceptions
    assertThat(logs.last().throwable).isNull()
  }

  @Test
  fun testLoggingEventListener() {

        try {
            userService.changePassword(username, form.newPassword);
            saveInfo(messages -> messages.addSuccessChangedPassword(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to change password for {}", username, e);
            throwValidationError(messages -> messages.addErrorsFailedToChangePassword(GLOBAL), toIndexPage);
        }
        return redirect(getClass());
    }

	for _, config := range dump.GetEcdsFilters() {
		c := &core.TypedExtensionConfig{}
		err := config.GetEcdsFilter().UnmarshalTo(c)
		if err != nil {
			return nil, fmt.Errorf("failed to retrieve TypedExtensionConfig: %v", err)
		}

		ecds = append(ecds, c)
	}

	sort.Slice(ecds, func(i, j int) bool {
		if ecds[i].GetTypedConfig().GetTypeUrl() == ecds[j].GetTypedConfig().GetTypeUrl() {

from the certificate files using `kubectl`: ``` kubectl -n minio create secret generic minio-trusted-certs --from-file=public.crt --from-file=keycloak.crt ``` If TLS is not enabled, you would need only the third party CA: ``` kubectl -n minio create secret generic minio-trusted-certs --from-file=keycloak.crt ``` The name of the generated secret can then be passed to Helm using a values file or the `--set` parameter: ``` trustedCertsSecret: "minio-trusted-certs" or --set trustedCertsSecret=minio-trusted-certs...

                resp.flushBuffer();
                return;
            }
        }

        try ( SmbFile file = openFile(pathInfo, server) ) {
            if ( file.isDirectory() ) {
                doDirectory(req, resp, file);
            }
            else {
                doFile(req, resp, file);
            }
        }
        catch ( SmbAuthException sae ) {
            if ( ssn != null ) {

            t.printStackTrace(pw);
            pw.flush();
            return systemHelper.abbreviateLongText(sw.toString());
        } catch (final IOException e) {
            logger.warn("Failed to print the stack trace {}", t.getMessage(), e);
        }
        return StringUtil.EMPTY;
    }

      if (foundTrustedCertificate) {
        return result
      }

      // The last link isn't trusted. Fail.
      throw SSLPeerUnverifiedException(
        "Failed to find a trusted cert that signed $toVerify",
      )
    }

    throw SSLPeerUnverifiedException("Certificate chain too long: $result")
  }

  /**

    /**
     * Set flag
     * 
     * @param flag
     */
    public void setFlag ( int flag ) {
        this.flags |= flag;
    }


    /**
     * 
     * @return result exception, if the call failed
     */
    public DcerpcException getResult () {
        if ( this.result != 0 )
            return new DcerpcException(this.result);
        return null;
    }


    void encode_header ( NdrBuffer buf ) {