* Ignoring a dependency does not mean lock state ignores its transitive dependencies.
* There is no validation that an ignored dependency is present in any configuration resolution.
* If the dependency is present in lock state, loading it will filter out the dependency.
* If the dependency is present in the resolution result, it will be ignored when validating that resolution matches the lock state.

        then:
        registry.all.empty
    }

    def "mark busy ignores entry that has been removed"() {
        given:
        def address = address()

        when:
        registry.markState(address, Busy)

        then:
        registry.all.empty
    }

    def "mark idle ignores entry that has been removed"() {
        given:
        def address = address()

        when:

on all systems.

If the program was started with SIGHUP or SIGINT ignored, and [Notify]
is called for either signal, a signal handler will be installed for
that signal and it will no longer be ignored. If, later, [Reset] or
[Ignore] is called for that signal, or [Stop] is called on all channels
passed to Notify for that signal, the signal will once again be
ignored. Reset will restore the system default behavior for the

            package io.another;

            public class BaseExample {}
        '''
        file("src/main/ignoredJava/ignored/module-info.java") << 'module ignored { exports io.ignored; }'
        file("src/main/ignoredJava/ignored/io/ignored/IgnoredExample.java") << '''
            package io.ignored;

            public class IgnoredExample {}
        '''

        when:
        run "compileJava"

        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        where:
        api << Api.values()
    }

    def "empty directories are ignored when specified (#api, #pathSensitivity)"() {
        createTaskWithSensitivity(DirectorySensitivity.IGNORE_DIRECTORIES, api, pathSensitivity)
        buildFile << """
            taskWithInputs {

	KubeletExtraArgs []Arg

	// IgnorePreflightErrors provides a slice of pre-flight errors to be ignored when the current node is registered, e.g. 'IsPrivilegedUser,Swap'.
	// Value 'all' ignores errors from all checks.
	IgnorePreflightErrors []string

	// ImagePullPolicy specifies the policy for image pulling during kubeadm "init" and "join" operations.

    }

    // instance method ignored
    public Object badIgnored() {
      return new BadEquals();
    }

    // primitive ignored
    public int returnsInt() {
      throw new UnsupportedOperationException();
    }

    // void ignored
    public void voidMethod() {
      throw new UnsupportedOperationException();
    }

    // non-public method ignored
    static Object badButNotPublic() {

            @DisableCachingByDefault(because = "test task")
            public class MyTask extends DefaultTask {
                // Should be ignored because it's not a getter
                public void getVoid() {
                }

                // Should be ignored because it's not a getter
                public int getWithParameter(int count) {
                    return count;
                }

	f.mutex.Unlock()
	return n
}

// AddLine adds the line offset for a new line.
// The line offset must be larger than the offset for the previous line
// and smaller than the file size; otherwise the line offset is ignored.
func (f *File) AddLine(offset int) {
	f.mutex.Lock()
	if i := len(f.lines); (i == 0 || f.lines[i-1] < offset) && offset < f.size {
		f.lines = append(f.lines, offset)
	}
	f.mutex.Unlock()
}

                    phaseHasMoreProgress(startEvent);
                } else if (startEvent.getBuildOperationCategory() == BuildOperationCategory.CONFIGURE_PROJECT && currentPhase == Phase.Configuring) {
                    // Any configuring event received from nested or buildSrc builds before the root build starts configuring is ignored