# For this module, Go 1.17 produces an error for one module, and Go 1.16
# produces a different error for a different module.

cp go.mod go.mod.orig

! go mod tidy

stderr '^go: example\.com/m imports\n\texample\.net/added: module example\.net/added@latest found \(v0\.3\.0, replaced by \./a1\), but does not contain package example\.net/added$'

cmp go.mod go.mod.orig

# Make sure that -diff behaves the same as tidy.

packages" which are more sophisticated than Go's `internal` convention.

If inverse rules are found, then all known imports of the package are checked
against each such rule, in the same fashion as regular rules.  Note that this
can only handle known imports, which is defined as any package which is also
being considered by this `import-boss` run.  For most repositories, `./...` will
suffice.

Example:

import java.net.URL;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class DefaultImportsReader implements ImportsReader {

    public static final String RESOURCE = "/default-imports.txt";
    private static final String MAPPING_RESOURCE = "/api-mapping.txt";
    private final String[] importPackages;
    private final Map<String, List<String>> simpleNameToFQCN;

    public DefaultImportsReader() {

import org.gradle.internal.HasInternalProtocol;

/**
 * This class exposes a number of internal utilities for use by Gradle JVM plugins.
 */
@NonNullApi
@HasInternalProtocol
@SuppressWarnings({"UnusedReturnValue", "deprecation"})
public interface JvmPluginServices extends JvmEcosystemUtilities {

    /**
     * Registers a variant on {@code configuration} which exposes the resources defined by {@code sourceSet}.
     *

    }

    private fun SmartPrinter.collectAndPrintImports(diagnosticList: HLDiagnosticList) {
        val imports = collectImports(diagnosticList)
        printImports(imports)
    }

    protected fun SmartPrinter.printHeader(packageName: String, diagnosticList: HLDiagnosticList) {
        printCopyright()
        println("package $packageName")

                testExecutionResult.assertTestPassed(testCase.getName());
            }
        }
    }

    public Set<String> getImports() {
        return imports;
    }

    public XCTestSourceFileElement withImport(String importName) {
        imports.add(importName);
        return this;
    }

    public Set<String> getTestableImports() {
        return testableImports;
    }

// other, mirroring the import dependencies. So if package p
// imports package q, then there will be a dependency p -> q.
// We can't initialize package p until after package q has
// already been initialized.
//
// Package dependencies are encoded with relocations. If package
// p imports package q, then package p's inittask record will
// have a R_INITORDER relocation pointing to package q's inittask

import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class ImplicitImportsTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `implicit imports are fully qualified to allow use of the preferred type amongst those with same simple name in different Gradle API packages`() {

        // given:
        withBuildScript(
            """

 */
trait DynamicGroovyPluginMixin {
    void withPluginCode(String imports, String codeUnderTest, boolean enableIndy) {
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${Plugin.name}
            import ${Project.name}

            $imports

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {

		if p.Doc == "" && !isTest && !isXTest {
			if synopsis := tf.synopsis(); synopsis != "" {
				p.Doc = synopsis
			}
		}

		// Record Imports and information about cgo.
		isCgo := false
		imports := tf.imports()
		for _, imp := range imports {
			if imp.path == "C" {
				if isTest {
					badGoFile(name, fmt.Errorf("use of cgo in test %s not supported", name))
					continue
				}
				isCgo = true