//this if is a bit cheesy but 1-letter classname surely means a generic type and the warning will be useless
        if (className.length() > 1) {
            listener.warning(String.format("Could not generate link for unknown class '%s'", className));
        }
        Element element = document.createElement("classname");
        element.appendChild(document.createTextNode(className));
        return element;
    }

     */
    @Nonnull
    String getSource();

    /**
     * Gets the one-based index of the line containing the problem. The line number should refer to some text file that
     * is given by {@link #getSource()}.
     *
     * @return the one-based index of the line containing the problem or a non-positive value if unknown
     */
    int getLineNumber();

        DefaultProjectBuildingResult result = new DefaultProjectBuildingResult(null, null, problems);
        results.add(result);

        ProjectBuildingException exception = new ProjectBuildingException(results);
        String message = exception.getMessage();

    val responseString = decompressed.body.string()
    assertThat(responseString).isEqualTo("hello not compressed world")
  }

  @Test
  fun testUnknownAlgorithm() {
    val s = "hello unknown algorithm world".encodeUtf8()

    val response =
      response("https://example.com/", s) {
        header("Content-Encoding", "deflate")
      }

    val decompressed = zstdInterceptor.decompress(response)

    private final String lifecycleId;

    /**
     * Creates a new exception to indicate that the specified lifecycle is unknown.
     *
     * @param lifecycleId The identifier of the lifecycle that could not be located, may be {@code null}.
     */
    public LifecycleNotFoundException(String lifecycleId) {
        super("Unknown lifecycle " + lifecycleId);
        this.lifecycleId = (lifecycleId != null) ? lifecycleId : "";
    }

    /**

        buffer.append((groupId != null && !groupId.isEmpty()) ? groupId : "[unknown-group-id]");
        buffer.append(':');
        buffer.append((artifactId != null && !artifactId.isEmpty()) ? artifactId : "[unknown-artifact-id]");
        buffer.append(':');
        buffer.append((version != null && !version.isEmpty()) ? version : "[unknown-version]");

        return buffer.toString();
    }

    /**

        StringBuilder id = new StringBuilder(128);

        id.append((getGroupId() == null) ? "[unknown-group-id]" : getGroupId());
        id.append(":");
        id.append((getArtifactId() == null) ? "[unknown-artifact-id]" : getArtifactId());
        id.append(":");
        id.append((getVersion() == null) ? "[unknown-version]" : getVersion());

        return id.toString();
    }

object JsseDebugLogging {
  data class JsseDebugMessage(
    val message: String,
    val param: String?,
  ) {
    enum class Type {
      Handshake,
      Plaintext,
      Encrypted,
      Setup,
      Unknown,
    }

    val type: Type
      get() =
        when {
          message == "adding as trusted certificates" -> Type.Setup
          message == "Raw read" || message == "Raw write" -> Type.Encrypted

     * @param message The detail message of the problem, may be {@code null}.
     * @param line The one-based index of the line containing the problem or {@code -1} if unknown.
     * @param column The one-based index of the column containing the problem or {@code -1} if unknown.
     * @param cause The cause of the problem, may be {@code null}.
     */
    void add(Problem.Severity severity, String message, int line, int column, Exception cause);

		case "P-224":
			curve = elliptic.P224()
		case "P-256":
			curve = elliptic.P256()
		case "P-384":
			curve = elliptic.P384()
		case "P-521":
			curve = elliptic.P521()
		default:
			return nil, fmt.Errorf("Unknown curve type: %s", key.Crv)
		}

		xbuf, err := base64.RawURLEncoding.DecodeString(key.X)
		if err != nil {
			return nil, errMalformedJWKECKey
		}

		ybuf, err := base64.RawURLEncoding.DecodeString(key.Y)