*/

package org.gradle.internal.execution.history.changes

import org.gradle.api.Describable
import org.gradle.api.GradleException
import spock.lang.Specification

class ErrorHandlingChangeContainerTest extends Specification {
    def task = Stub(Describable) {
        getDisplayName() >> "task ':test'"
    }
    def delegate = Mock(ChangeContainer)
    def changes = new ErrorHandlingChangeContainer(task, delegate)

        when:
        cachingChanges.accept(collectingVisitor)
        def reported = collectingVisitor.changes

        then:
        interaction {
            receivesChanges(change1, change2)
        }
        0 * _

        and:
        reported == [change1, change2]
    }

    private void receivesChanges(Change... changes) {
        1 * delegate.accept(_) >> { args ->
            ChangeVisitor visitor = args[0]

import org.gradle.internal.execution.history.changes.ExecutionStateChanges

import java.time.Duration

import static org.gradle.internal.execution.ExecutionEngine.Execution
import static org.gradle.internal.execution.ExecutionEngine.ExecutionOutcome.UP_TO_DATE

class SkipUpToDateStepTest extends StepSpec<IncrementalChangesContext> {
    def step = new SkipUpToDateStep<>(delegate)
    def changes = Mock(ExecutionStateChanges)

		case '!', '#', '$', '&', '*', '+', ',', '/', ':', ';', '=', '?', '@', '[', ']':
			if norm {
				continue
			}
		// Unreserved according to RFC 3986 sec 2.3
		// "For consistency, percent-encoded octets in the ranges of
		// ALPHA (%41-%5A and %61-%7A), DIGIT (%30-%39), hyphen (%2D),
		// period (%2E), underscore (%5F), or tilde (%7E) should not be
		// created by URI producers
		case '-', '.', '_', '~':
			continue
		case '%':

     */
    enum ChangeBehavior {
        /**
         * When changes are detected, wait for a deployment request before rebuilding.
         *
         * The deployment needs to call {@link Deployment#status()} to trigger a rebuild wait for changes.
         */
        BLOCK_AND_REBUILD,

        /**
         * When changes are detected, block the deployment until all changes are incorporated.
         *

	api "k8s.io/kubernetes/pkg/apis/core"
	"k8s.io/kubernetes/pkg/registry/core/limitrange"
)

// REST implements a RESTStorage for limit ranges.
type REST struct {
	*genericregistry.Store
}

// NewREST returns a RESTStorage object that will work against limit ranges.
func NewREST(optsGetter generic.RESTOptionsGetter) (*REST, error) {
	store := &genericregistry.Store{

     *     <li>Changes for the property cannot be queried via {@link org.gradle.work.InputChanges}</li>
     * </ul>
     */
    NON_INCREMENTAL(false, false),

    /**
     * Incremental inputs.
     *
     * <ul>
     *     <li>Changes to the property value can cause an incremental execution of the work</li>

type processServiceMapChangeFunc func(previous, current ServicePortMap)

// serviceChange contains all changes to services that happened since proxy rules were synced.  For a single object,
// changes are accumulated, i.e. previous is state from before applying the changes,
// current is state after applying all of the changes.
type serviceChange struct {
	previous ServicePortMap
	current  ServicePortMap
}

	endlines := make(map[ID]src.XPos)
	ranges := make(map[int]lineRange)
	note := func(p src.XPos) {
		line := uint32(p.Line())
		i := int(p.FileIndex())
		lp, found := ranges[i]
		change := false
		if line < lp.first || !found {
			lp.first = line
			change = true
		}
		if line > lp.last {
			lp.last = line
			change = true
		}
		if change {
			ranges[i] = lp
		}
	}

    }

    def "should report the absolute file path of the created files up to the limit and 'and some more changes' when the number of files added to the input directory is over the limit"() {
        given:
        // We need to put these files in subdirectories, since on Linux we'd stop watching a directory as soon as we
        // received file changes for all the files inside.
        def inputSubdirectories = (1..9).collect { inputDir.createDir("subdir${it}")}