import static java.util.Objects.requireNonNull;

/**
 * Proto {@link Logger} that just passes to functioning {@link org.slf4j.Logger} instance.
 */
public class Slf4jLogger implements Logger {
    private final org.slf4j.Logger logger;

    public Slf4jLogger(org.slf4j.Logger logger) {
        this.logger = requireNonNull(logger, "logger");
    }

    @Override

 */

plugins {
    id("java-library")
    id("groovy-gradle-plugin")
    id("gradlebuild.code-quality")
    id("gradlebuild.ci-reporting")
    id("gradlebuild.test-retry")
    id("gradlebuild.private-javadoc")
}

dependencies {
    api(platform("gradlebuild:build-platform"))
    implementation("gradlebuild:gradle-plugin")

    implementation(localGroovy())

        assertEquals(2, deps.size());
        checkUtSimpleArtifactDependencies(deps.get(0), deps.get(1));
    }

    /**
     * check ut.simple:artifact:1.0 dependencies
     */
    private void checkUtSimpleArtifactDependencies(Dependency dep1, Dependency dep2) {
        assertEquals("compile", dep1.getScope());
        assertFalse(dep1.isOptional(), "Expected " + dep1 + ".isOptional() to return false");

    }

    private void assertIsSuccessor(BuildStep predecessor, BuildStep successor) {
        assertTrue(
                successor.isSuccessorOf(predecessor),
                String.format("Expected '%s' to be a successor of '%s'", successor.toString(), predecessor.toString()));
    }

    @SuppressWarnings("checkstyle:UnusedLocalVariable")

import org.eclipse.aether.installation.InstallRequest;

import static java.util.Objects.requireNonNull;

@Singleton
@Named
public class DefaultTransformerManager implements TransformerManager {
    private final Map<String, PomArtifactTransformer> transformers;

    @Inject
    public DefaultTransformerManager(Map<String, PomArtifactTransformer> transformers) {
        this.transformers = requireNonNull(transformers);
    }

 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @since 3.0
 */
public class ExecutionPlanItem {
    private final MojoExecution mojoExecution;

    public ExecutionPlanItem(MojoExecution mojoExecution) {
        this.mojoExecution = mojoExecution;
    }

    public static List<ExecutionPlanItem> createExecutionPlanItems(

 */
@Deprecated(since = "4.0.0")
public class MavenToolchainsXpp3Writer {
    // --------------------------/
    // - Class/Member Variables -/
    // --------------------------/

    private final MavenToolchainsStaxWriter delegate;

    public MavenToolchainsXpp3Writer() {
        delegate = new MavenToolchainsStaxWriter();
        delegate.setAddLocationInformation(false);
    }

    /**

            plugins.add(newPlugin("maven-deploy-plugin", "deploy"));
        } else {
            plugins = Collections.emptySet();
        }

        return plugins;
    }

    private Plugin newPlugin(String artifactId, String... goals) {
        Plugin plugin = new Plugin();

        plugin.setGroupId("org.apache.maven.plugins");
        plugin.setArtifactId(artifactId);

            nullawayIncompatibleDeps.isEmpty() -> service.addProjectToEnableNullawayIn(projectPath)
            else -> service.addProjectWithUncheckedDeps(projectPath)
        }
    }

    private val ResolvedArtifactResult.hasNullAwayDisabled
        get() = variant.attributes.getAttribute(NullawayAttributes.nullawayAttribute) == NullawayState.DISABLED

 */

package gradlebuild.binarycompatibility

import org.junit.Test

class JSpecifyNullUnmarkedChangesTest : AbstractBinaryCompatibilityTest() {

    private val nullableAnnotationName = "org.jspecify.annotations.Nullable"
    private val nullUnmarkedAnnotationName = "org.jspecify.annotations.NullUnmarked"

    @Test
    fun `from non-null returning to null-unmarked returning is breaking`() {