PluginInfo pluginInfo = extractPluginInfo(artifact);
            if (pluginInfo != null) {
                String key = pluginInfo.groupId;
                if (processedPlugins.get(key) == null) {
                    PluginsMetadata pluginMetadata = plugins.get(key);
                    if (pluginMetadata == null) {
                        pluginMetadata = new PluginsMetadata(pluginInfo, timestamp);

                    val someVal: String? = null
                    var someVar: String? = null
                    fun foo(): String? = null
                }
            """
        ) {
            assertHasErrors(
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change.",
                "Method com.example.Source.getSomeVal(): From non-null returning to null returning breaking change.",

                null, null, null))
        .addEqualityGroup(
            Tables.<String, @Nullable Object, @Nullable Object>immutableCell("bar", null, null))
        .addEqualityGroup(
            Tables.<@Nullable Object, Integer, @Nullable Object>immutableCell(null, 2, null))
        .addEqualityGroup(
            Tables.<@Nullable Object, @Nullable Object, Character>immutableCell(null, null, 'b'))

 *         .header("Proxy-Authorization", "secret")
 *         .build();
 *   }
 * }
 * return null; // Didn't find a preemptive auth scheme.
 * ```
 *
 * ## Reactive Authentication
 *
 * Implementations authenticate by returning a follow-up request that includes an authorization
 * header, or they may decline the challenge by returning null. In this case the unauthenticated
 * response will be returned to the caller that triggered it.
 *

        assertEquals(-1, problem.getColumnNumber());

        problem = new DefaultProblem(null, null, null, -1, 42, null);
        assertEquals(42, problem.getColumnNumber());

        problem = new DefaultProblem(null, null, null, -1, Integer.MAX_VALUE, null);
        assertEquals(Integer.MAX_VALUE, problem.getColumnNumber());

        // this case is not specified, might also return -1

        Set<Artifact> resolved = new LinkedHashSet<>();

        if (projects == null || projects.isEmpty()) {
            return resolved;
        }

        if ((scopesToCollect == null || scopesToCollect.isEmpty())
                && (scopesToResolve == null || scopesToResolve.isEmpty())) {
            return resolved;
        }

        /*

                return KILOBYTE;
            } else {
                return BYTE;
            }
        }
    }

    public String format(long size) {
        return format(size, null);
    }

    public String format(long size, ScaleUnit unit) {
        return format(size, unit, false);
    }

    public String format(long size, ScaleUnit unit, boolean omitSymbol) {

    // gather artifactIds which are not unique so that the respective thread names can be extended with the groupId
    public Set<String> duplicateIds() {
        if (duplicateIds == null) {
            synchronized (this) {
                if (duplicateIds == null) {
                    duplicateIds = projects()
                            .map(MavenProject::getArtifactId)

    if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER &&
      (entry == null || entry.sequenceNumber != expectedSequenceNumber)
    ) {
      return null // Snapshot is stale.
    }

    if (entry?.currentEditor != null) {
      return null // Another edit is in progress.
    }

    if (entry != null && entry.lockingSourceCount != 0) {
      return null // We can't write this file because a reader is still reading it.
    }

    }

    private String emptify(String string) {
        return (string != null) ? string : "";
    }

    @Override
    public File getFile() {
        return null;
    }

    @Override
    public MetadataBridge setFile(File file) {
        return this;
    }

    @Override
    public Path getPath() {
        return null;
    }

    @Override
    public Nature getNature() {