*/
public class BuildAbort extends Error {

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

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

  static final class SomeUncheckedException extends RuntimeException {}

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

  private TestExceptions() {}

  static class SomeUncheckedException extends RuntimeException {}

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

  private TestExceptions() {}

        // GIVEN an unknown auth type
        int unknownAuthType = -1;
        byte[] emptyToken = new byte[0];

        // WHEN parsing the auth data
        List<KerberosAuthData> result = KerberosAuthData.parse(unknownAuthType, emptyToken, mockKeys);

        // THEN the result should be an empty list
        assertNotNull(result, "The result should not be null.");

            latestAgpVersions.firstBaseVersion,
            latestAgpVersions.last()
        )

    private
    val List<String>.firstBaseVersion: String
        get() = VersionNumber.parse(first()).minorBaseVersion

    private
    val VersionNumber.minorBaseVersion: String
        get() = "$major.$minor"

    private

            super(message);
        }

        /**
         * Create exception with cause
         *
         * @param message error message
         * @param cause underlying cause
         */
        public NoAvailableChannelException(String message, Throwable cause) {
            super(message, cause);
        }
    }

			<-*block
		}

		if c.incomingBytes != nil {
			c.incomingBytes(int64(len(msg)))
		}

		// Parse the received message
		var m message
		subID, remain, err := m.parse(msg)
		if err != nil {
			if !xnet.IsNetworkOrHostDown(err, true) {
				gridLogIf(ctx, fmt.Errorf("ws parse package: %w", err))
			}
			return
		}
		if debugPrint {
			fmt.Printf("%s Got msg: %v\n", c.Local, m)
		}

    public InvalidDependencyVersionException(
            String projectId, Dependency dependency, File pomFile, InvalidVersionSpecificationException cause) {
        super(projectId, formatLocationInPom(dependency), dependency.getVersion(), pomFile, cause);
        this.dependency = dependency;
    }

    private static String formatLocationInPom(Dependency dependency) {

    } catch (e: IllegalAccessException) {
      throw AssertionError(e)
    } catch (e: InvocationTargetException) {
      // https://github.com/square/okhttp/issues/5587
      val cause = e.cause
      when {
        cause is NullPointerException && cause.message == "ssl == null" -> null
        else -> throw AssertionError(e)
      }
    }
  }

  companion object {
    val playProviderFactory: DeferredSocketAdapter.Factory =

     */
    public CommandExecutionException(final String message) {
        super(message);
    }

    /**
     * Constructor with error message and cause.
     * @param message The error message describing the command execution failure.
     * @param e The cause of the exception.
     */
    public CommandExecutionException(final String message, final Throwable e) {
        super(message, e);
    }