builder.startObject();
        if (sessionId != null) {
            builder.field(SESSION_ID, sessionId);
        }
        if (ruleId != null) {
            builder.field(RULE_ID, ruleId);
        }
        if (url != null) {
            builder.field(URL, url);
        }
        if (parentUrl != null) {
            builder.field(PARENT_URL, parentUrl);
        }

        sb.append("   layout: ").append(layout != null ? layout : "none").append('\n');

        if (snapshots != null) {
            sb.append("snapshots: [enabled => ").append(snapshots.isEnabled());
            sb.append(", update => ").append(snapshots.getUpdatePolicy()).append("]\n");
        }

        if (releases != null) {
            sb.append(" releases: [enabled => ").append(releases.isEnabled());

private fun checkSupportResponse(
  name: String,
  response: Response?,
) {
  response?.apply {
    require(networkResponse == null) { "$name.networkResponse != null" }
    require(cacheResponse == null) { "$name.cacheResponse != null" }
    require(priorResponse == null) { "$name.priorResponse != null" }
  }
}

fun Response.Builder.commonPriorResponse(priorResponse: Response?) =
  apply {

            getMap()
                .computeIfAbsent(
                    null,
                    k -> {
                      assertNull(k);
                      return v3();
                    }));
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported computeIfAbsent(null, function)");
  }

        if (deploymentTimestamp == null) {
            deploymentTimestamp = getUtcDateFormatter().format(new Date());
        }
        return deploymentTimestamp;
    }

    protected String constructVersion(Versioning versioning, String baseVersion) {
        String version = null;
        Snapshot snapshot = versioning.getSnapshot();
        if (snapshot != null) {

      return spliterator.tryAdvance(action);
    }

    @Override
    @Nullable GeneralSpliterator<E> trySplit() {
      Spliterator<E> split = spliterator.trySplit();
      return split == null ? null : new GeneralSpliteratorOfObject<>(split);
    }
  }

  @IgnoreJRERequirement // *should* be redundant with the annotation on SpliteratorTester
  private static final class GeneralSpliteratorOfPrimitive<

      return spliterator.tryAdvance(action);
    }

    @Override
    @Nullable GeneralSpliterator<E> trySplit() {
      Spliterator<E> split = spliterator.trySplit();
      return split == null ? null : new GeneralSpliteratorOfObject<>(split);
    }
  }

  private static final class GeneralSpliteratorOfPrimitive<
          E extends @Nullable Object, C, S extends Spliterator.OfPrimitive<E, C, S>>

                    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) {

        Model source = Model.newBuilder().artifactId("SOURCE").build();

        Model merged = mavenMerger.merge(target, source, true, null);
        assertThat(merged.getArtifactId(), is("SOURCE"));

        merged = mavenMerger.merge(target, source, false, null);
        assertThat(merged.getArtifactId(), is("TARGET"));
    }

    @Test
    void mergeSameContributors() {
        Contributor contributor =

        if (createdBy != null) {
            addFieldToSource(sourceMap, "createdBy", createdBy);
        }
        if (createdTime != null) {
            addFieldToSource(sourceMap, "createdTime", createdTime);
        }
        if (generator != null) {
            addFieldToSource(sourceMap, "generator", generator);
        }
        if (path != null) {
            addFieldToSource(sourceMap, "path", path);