}
        Throwable cause = projectExecutionEvent.getCause();
        buildEventListener.executionFailure(
                projectExecutionEvent.getProject().getArtifactId(), halted, cause != null ? cause.toString() : null);
    }

    @Override
    public void projectDiscoveryStarted(ExecutionEvent event) {
        setMdc(event);

import org.apache.maven.api.annotations.Experimental;

@Experimental
public class ChecksumAlgorithmServiceException extends MavenException {

    public ChecksumAlgorithmServiceException(String message, Throwable cause) {
        super(message, cause);
    }

 */
@Deprecated
public class ExpressionDocumentationException extends Exception {
    static final long serialVersionUID = 1;

    public ExpressionDocumentationException(String message, Throwable cause) {
        super(message, cause);
    }

    public ExpressionDocumentationException(String message) {
        super(message);
    }

     */
    @JvmStatic
    @JvmName("get")
    fun String.toHttpUrl(): HttpUrl = Builder().parse(null, this).build()

    /**
     * Returns a new `HttpUrl` representing `url` if it is a well-formed HTTP or HTTPS URL, or null
     * if it isn't.
     */
    @JvmStatic
    @JvmName("parse")
    fun String.toHttpUrlOrNull(): HttpUrl? =
      try {
        toHttpUrl()

  static final class SomeUncheckedException extends RuntimeException {}

  static final class SomeChainingException extends RuntimeException {
    public SomeChainingException(Throwable cause) {
      super(cause);
    }
  }

  private TestExceptions() {}

        final ConverterRuntimeException e = new ConverterRuntimeException("hoge", "xxx", new RuntimeException("cause"));
        System.out.println(e.getMessage());
        assertThat(e.getPropertyName(), is("hoge"));
        assertThat(e.getValue(), is((Object) "xxx"));
        assertThat(e.getCause().getMessage(), is("cause"));
    }

	// Channel will be closed after error or when remote closes.
	// All responses *must* be read by the caller until either an error is returned or the channel is closed.
	// Canceling the context will cause the context cancellation error to be returned.
	responses <-chan Response
	cancel    context.CancelCauseFunc

	// Requests sent to the server.
	// If the handler is defined with 0 incoming capacity this will be nil.

		t.Run(tt.name, func(t *testing.T) {
			gotArn, err := Parse(tt.args.arnStr)
			if err == nil && tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err != nil && !tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err == nil {
				if !reflect.DeepEqual(gotArn, tt.wantArn) {
					t.Errorf("Parse() gotArn = %v, want %v", gotArn, tt.wantArn)
				}
			}

import okhttp3.MediaType.Companion.toMediaType

open class MediaTypeGetTest : MediaTypeTest() {
  override fun parse(string: String): MediaType = string.toMediaType()

  override fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {
    val e =
      assertFailsWith<IllegalArgumentException> {
        parse(string)
      }
    assertEquals(exceptionMessage, e.message)
  }

        if (handlerParameterMap == null) {
            handlerParameterMap = ParameterUtil.parse(getHandlerParameter());
        }
        return handlerParameterMap;
    }

    public Map<String, String> getHandlerScriptMap() {
        if (handlerScriptMap == null) {
            handlerScriptMap = ParameterUtil.parse(getHandlerScript());
        }
        return handlerScriptMap;
    }

    @Override