// -----------------------------------------------------------------------------------------------

    protected void assertPluginDescriptor(
            MojoDescriptor mojoDescriptor, String groupId, String artifactId, String version) {
        assertNotNull(mojoDescriptor);
        PluginDescriptor pd = mojoDescriptor.getPluginDescriptor();
        assertNotNull(pd);
        assertEquals(groupId, pd.getGroupId());

func TestBuffConnReadTimeout(t *testing.T) {
	l, err := net.Listen("tcp", "localhost:0")
	if err != nil {
		t.Fatalf("unable to create listener. %v", err)
	}
	defer l.Close()
	serverAddr := l.Addr().String()

	tcpListener, ok := l.(*net.TCPListener)
	if !ok {
		t.Fatalf("failed to assert to net.TCPListener")
	}

	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		defer wg.Done()

    private final List<ArtifactRepository> resolutionRepositories;

    private final Artifact pomArtifact;

    private final Artifact relocatedArtifact;

    private final Map<String, Artifact> managedVersions;

    public ResolutionGroup(
            Artifact pomArtifact, Set<Artifact> artifacts, List<ArtifactRepository> resolutionRepositories) {

    }

    @Override
    public <T> T lookup(Class<T> type, String name) {
        return null;
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.empty();
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return Optional.empty();
    }

    @Override

    override fun getName(): String = "IntegrationTestFixtures"

    override fun getPriority(): Int = 1

    override fun setPriority(priority: Int) {
        throw UnsupportedOperationException()
    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }

    override fun getDescription(): String = "Reports incorrect usages of integration test fixtures"

    private val failedTaskPaths = CopyOnWriteArrayList<String>()
    override val collectedInformation: Serializable = failedTaskPaths

    override fun shouldInclude(taskPath: String): Boolean {
        // https://github.com/gradle/gradle/issues/21351
        return super.shouldInclude(taskPath) || taskPath.contains("detekt")
    }

    override fun action(taskPath: String, taskResult: TaskOperationResult) {

            entry.select("ul li")
                .map { it.text() }

        )
    }


internal
data class ReportMessage(
    val message: String,
    val details: List<String>
)


internal
data class RichReport(
    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,
    val accepted: List<ReportMessage>
) {

        dependencies {
            snapshotDependencies(docsTestProject.docsTests)
        }
    })

enum class DocsTestType(
    val ccEnabled: Boolean,
    val docsTestName: String,
    val docsTestDesc: String,
) {
    CONFIG_CACHE_ENABLED(true, "ConfigCacheDocsTest", "Docs Test With Config Cache Enabled"),
    CONFIG_CACHE_DISABLED(false, "DocsTest", "Docs Test"),
}

class DocsTest(

pkg p2, func F //deprecated
pkg p2, func F() string
pkg p2, func G() Twoer
pkg p2, func NewError(string) error
pkg p2, type Twoer interface { PackageTwoMeth }
pkg p2, type Twoer interface, PackageTwoMeth //deprecated

 *
 * <p>
 * Usage example:
 * </p>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 *
 * List&lt;String&gt; list = ...;
 * for (Indexed&lt;String&gt; indexed : indexed(list)) {
 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * <pre>