"""

        when:
        inputFile.text = "initial"
        runWithFileSystemWatchingAndMakeChangesWhen("waitForUserChanges", "userInput") {
            inputFile.text = "changed"
            waitForChangesToBePickedUp()
        }
        then:
        executedAndNotSkipped(":consumer")
        outputFile.text == "initial"
        assertExpectedProjectFilesInVfs(1)

        when:

			// let the CRD controller process the initial set of CRDs before starting the autoregistration controller.
			// this prevents the autoregistration controller's initial sync from deleting APIServices for CRDs that still exist.
			// we only need to do this if CRDs are enabled on this server.  We can't use discovery because we are the source for discovery.
			if crdAPIEnabled {
				klog.Infof("waiting for initial CRD sync...")

2. License Grants.

    2.1. The Initial Developer Grant.

    Conditioned upon Your compliance with Section 3.1 below and subject
    to third party intellectual property claims, the Initial Developer
    hereby grants You a world-wide, royalty-free, non-exclusive license:

    (a) under intellectual property rights (other than patent or
    trademark) Licensable by Initial Developer, to use, reproduce,

     *
     * @since 5.0
     */
    DirectoryProperty directoryProperty();

    /**
     * Creates a new {@link RegularFileProperty} that uses the project directory to resolve relative paths, if required. The property has no initial value.
     *
     * @since 5.0
     */
    RegularFileProperty fileProperty();

		etcdLocalhostAddress = "::1"
	}
	defaultArguments := []kubeadmapi.Arg{
		{Name: "name", Value: nodeName},
		// TODO: start using --initial-corrupt-check once the graduated flag is available,
		// https://github.com/kubernetes/kubeadm/issues/2676
		{Name: "experimental-initial-corrupt-check", Value: "true"},

func (proxier *metaProxier) OnServiceDelete(service *v1.Service) {
	proxier.ipv4Proxier.OnServiceDelete(service)
	proxier.ipv6Proxier.OnServiceDelete(service)

}

// OnServiceSynced is called once all the initial event handlers were
// called and the state is fully propagated to local cache.
func (proxier *metaProxier) OnServiceSynced() {
	proxier.ipv4Proxier.OnServiceSynced()
	proxier.ipv6Proxier.OnServiceSynced()
}

     *
     * Our solution is for threads to CAS seenExceptions from null to a Set populated with _the
     * initial exception_, no matter which thread does the work. This ensures that seenExceptions
     * always contains not just the current thread's exception but also the initial thread's.
     */
    Set<Throwable> seenExceptionsLocal = seenExceptions;
    if (seenExceptionsLocal == null) {

        repoSpec.url = repo.url

        submoduleRepo.workTree.file("foo.txt") << "hello from submodule"
        submoduleRepo.commit("initial commit")

        submoduleRepo2.workTree.file("bar.txt") << "hello from another submodule"
        submoduleRepo2.commit("initial commit")
    }

    def 'clone a repository'() {
        given:
        def target = tmpDir.file('versionDir')

        when:

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |

		}
		// Skip calling all the existing state for secondary dependencies, otherwise we end up with a deadlock due to
		// rerunning the same collection's recomputation at the same time (once for the initial event, then for the initial registration).
		c.RegisterBatch(ff, false)
	})

	// Now we can do the real fetching
	// Compute our list of all possible objects that can match. Then we will filter them later.