package poll_test

import (
	"os"
	"runtime"
	"sync"
	"testing"
	"time"
)

func TestRead(t *testing.T) {
	t.Run("SpecialFile", func(t *testing.T) {
		var wg sync.WaitGroup
		for _, p := range specialFiles() {
			for i := 0; i < 4; i++ {
				wg.Add(1)
				go func(p string) {
					defer wg.Done()
					for i := 0; i < 100; i++ {
						if _, err := os.ReadFile(p); err != nil {

        version previous withTasks 'tasks' requireDaemon() requireIsolatedDaemons() run()
    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(current.version)

        expect:
        version current withTasks 'assemble' inDirectory(file("producer")) run()

        version current withTasks 'tasks' requireDaemon() requireIsolatedDaemons() run()
    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(previous.version)

        expect:
        version previous withTasks 'assemble' inDirectory(file("producer")) run()

import org.gradle.api.internal.attributes.AttributeContainerInternal;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;

import java.util.List;

/**
 * A {@link ResolutionFailure} that specializes {@link IncompatibleResolutionFailure} to represent the situation when a configuration is
 * requested by name but its attributes are not compatible with the request.
 */

 */

package org.gradle.internal.remote.internal;

import javax.annotation.Nullable;

/**
 * <p>A messaging end-point with some remote, or otherwise unreliable, peer.</p>
 *
 * <p>This interface simply specializes the exceptions thrown by the methods of this connection.</p>
 */
public interface RemoteConnection<T> extends Connection<T> {
    /**
     * {@inheritDoc}
     *

import org.gradle.api.internal.attributes.AttributeContainerInternal;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;

import java.util.List;

/**
 * A {@link ResolutionFailure} that specializes {@link IncompatibleResolutionFailure} to represent a
 * failure to select a variant for a component when building a dependency resolution graph.
 */

type ConfigForResource struct {
	// Config is the resource-independent configuration
	Config

	// GroupResource is the relevant one
	GroupResource schema.GroupResource
}

// ForResource specializes to the given resource
func (config *Config) ForResource(resource schema.GroupResource) *ConfigForResource {
	return &ConfigForResource{
		Config:        *config,
		GroupResource: resource,
	}
}

			d.off = i
			return
		}
	}

	d.off = len(data) + 1 // mark processed EOF with len+1
	d.opcode = d.scan.eof()
}

// rescanLiteral is similar to scanWhile(scanContinue), but it specialises the
// common case where we're decoding a literal. The decoder scans the input
// twice, once for syntax errors and to check the length of the value, and the
// second to perform the decoding.
//