/**
     * 
     * @param message
     * @param cause
     */
    public CIFSException ( String message, Throwable cause ) {
        super(message, cause);
    }


    /**
     * 
     * @param message
     */
    public CIFSException ( String message ) {
        super(message);
    }


    /**
     * 
     * @param cause
     */
    public CIFSException ( Throwable cause ) {

		statusCode: 400,
		cause:      err,
	}
}

func errColumnTooLong(err error) *s3Error {
	return &s3Error{
		code:       "ColumnTooLong",
		message:    "The length of a column in the result is greater than maxCharsPerColumn of 1 MB.",
		statusCode: 400,
		cause:      err,
	}
}

func errOverMaxColumn(err error) *s3Error {
	return &s3Error{

    }

    /**
     * Creates a new exception with specified cause
     *
     * @param cause
     * @param groupId
     * @param artifactId
     * @param version
     */
    public UnresolvableModelException(Throwable cause, String groupId, String artifactId, String version) {
        super(cause);
        this.groupId = groupId;
        this.artifactId = artifactId;

    assertSame(cause, getRootCause(exception));
  }

  public void testGetRootCause_loop() {
    Exception cause = new Exception();
    Exception exception = new Exception(cause);
    cause.initCause(exception);
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getRootCause(cause));
    assertThat(expected).hasCauseThat().isSameInstanceAs(cause);
  }

     *
     * <p>Note that the detail message associated with {@code cause} is <i>not</i>
     * automatically incorporated in this exception's detail message.</p>
     *
     * @param message the detail message (which is saved for later retrieval
     *                by the {@link #getMessage()} method).
     * @param cause   the cause (which is saved for later retrieval by the

   */
  public ExecutionError(@CheckForNull String message, @CheckForNull Error cause) {
    super(message, cause);
  }

  /**
   * Creates a new instance with {@code null} as its detail message and the given cause. Prefer to
   * provide a non-nullable {@code cause}, as many users expect to find one.
   */
  public ExecutionError(@CheckForNull Error cause) {
    super(cause);
  }

    assertThat(expected).hasCauseThat().isEqualTo(cause);

    Object newValue = new Object();
    valueRef.set(newValue);
    assertSame(newValue, cache.getUnchecked(new Object()));
  }

  public void testGetUnchecked_unchecked() {
    final RuntimeException cause = new RuntimeException();
    final AtomicReference<Object> valueRef = new AtomicReference<>();
    LoadingCache<Object, Object> cache =

        this(message, -1, -1, cause);
    }

    public ModelParserException(String message, int lineNumber, int columnNumber, Throwable cause) {
        super(message, cause);
        this.lineNumber = lineNumber;
        this.columnNumber = columnNumber;
    }

    public ModelParserException(Throwable cause) {
        this(null, cause);
    }

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

  public static final class TwoArgConstructorRuntimeException extends RuntimeException {
    public TwoArgConstructorRuntimeException(String message, Throwable cause) {
      super(message, cause);
    }
  }

  public static final class ExceptionWithPrivateConstructor extends Exception {

     * @param messageCode message code
     * @param cause cause of exception
     */
    public ClRuntimeException(final String messageCode, final Throwable cause) {
        this(messageCode, new Object[0], cause);
    }

    /**
     * Creates {@link ClRuntimeException}.
     *
     * @param messageCode message code
     * @param args arguments for messages
     * @param cause cause of exception
     */