default void log(@Nonnull Level level, @Nonnull String message) {
        log(level, message, null);
    }

    /**
     * Logs a message at the specified level with an associated exception.
     *
     * @param level the severity level of the message
     * @param message the message to be logged
     * @param error the associated exception, or null if not applicable
     */

            writer.accept("\t\tGoal:                   " + mojoExecId);
        }
        if (mojoExecution.getConfiguration() != null) {
            writer.accept("\t\tConfiguration:          " + mojoExecution.getConfiguration());
        }
        if (mojoExecution.getMojoDescriptor().getDependencyCollectionRequired() != null) {
            writer.accept("\t\tDependencies (collect): "

        artifacts.add(new DefaultArtifact("g", "a2", "v", "compile", "jar", "", null));
        artifacts.add(new DefaultArtifact("g", "a3", "v", "compile", "jar", "", null));
        artifacts.add(new DefaultArtifact("g", "a4", "v", "compile", "jar", "", null));

        cache.put(project1, new SetWithResolutionResult(null, artifacts));

        assertArrayEquals(

    } else if (previousValue instanceof PredAndSucc) {
      adjacentNodeValues.put((N) node, PRED);
      removedValue = ((PredAndSucc) previousValue).successorValue;
    } else { // successor
      adjacentNodeValues.remove(node);
      removedValue = previousValue;
    }

    if (removedValue != null) {
      checkNonNegative(--successorCount);

      if (orderedNodeConnections != null) {

                mavenSession, mock(RepositorySystem.class), null, null, new DefaultLookup(container), null);

        MojoExecution mojoExecution = newMojoExecution(session);

        return new PluginParameterExpressionEvaluatorV4(
                session, project != null ? new DefaultProject(session, project) : null, mojoExecution);
    }

    private MojoExecution newMojoExecution(Session session) {

    assertNull("get(notPresent) should return null", get(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedButAllowed() {
    assertNull("get(null) should return null", get(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedAndUnsupported() {
    try {
      assertNull("get(null) should return null or throw", get(null));

                    e);

            return null;
        }

        return artifactFactory.createPluginArtifact(plugin.getGroupId(), plugin.getArtifactId(), versionRange);
    }

    public ArtifactRepositoryPolicy buildArtifactRepositoryPolicy(RepositoryPolicy policy) {
        boolean enabled = true;

        String updatePolicy = null;

        String checksumPolicy = null;

        if (policy != null) {

                Map<String, String> headers = null;
                Integer connectTimeout = null;
                Integer requestTimeout = null;

                PlexusConfiguration httpHeaders = config.getChild("httpHeaders", false);
                if (httpHeaders != null) {
                    PlexusConfiguration[] properties = httpHeaders.getChildren("property");

        if (os == null) {
            return false;
        }
        return true;
    }

    private boolean ensureAtLeastOneNonNull(ActivationOS os) {
        return os.getArch() != null || os.getFamily() != null || os.getName() != null || os.getVersion() != null;
    }

    private boolean determineVersionMatch(String expectedVersion, String actualVersion) {
        String test = expectedVersion;

internal class RealEventSource(
  private val request: Request,
  private val listener: EventSourceListener,
) : EventSource,
  ServerSentEventReader.Callback,
  Callback {
  private var call: Call? = null

  @Volatile private var canceled = false

  fun connect(callFactory: Call.Factory) {
    call =
      callFactory.newCall(request).apply {
        enqueue(this@RealEventSource)
      }
  }