def targetDir = tmpDir.createDir("target")
        def tooManyRange = (1..(DefaultDeleter.MAX_REPORTED_PATHS + 10))
        def nonDeletableFiles = tooManyRange.collect { targetDir.createFile("zzz-${it}-zzz.txt") }
        FileTime.makeOld(nonDeletableFiles + targetDir)

        and: 'a deleter that cannot delete, records deletion requests and creates new files'
        def triedToDelete = [] as Set<File>

  "ipam": {},
  "dns": {},
  "plugin_log_level": "debug",
  "log_uds_address": "",
  "cni_event_address": "/tmp/cnieventfoo",
  "ambient_enabled": false,
  "kubernetes": {
    "kubeconfig": "/etc/cni/net.d/ZZZ-istio-cni-kubeconfig",
    "exclude_namespaces": [
      "istio-system"
    ]
  }

    suite.addTest(testsForTransform());
    suite.addTestSuite(Collections2Test.class);
    return suite;
  }

  static final Predicate<@Nullable String> NOT_YYY_ZZZ =
      input -> !"yyy".equals(input) && !"zzz".equals(input);

  static final Predicate<String> LENGTH_1 = input -> input.length() == 1;

  @J2ktIncompatible
  @GwtIncompatible // suite
  private static Test testsForFilter() {

    filtered.put("a", 1);
    filtered.put("b", 2);
    assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered);

    try {
      filtered.putAll(ImmutableMap.of("c", 3, "zzz", 4, "b", 5));
      fail();
    } catch (IllegalArgumentException expected) {
    }

    assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered);
  }

	Alias16 = SliceFlag[[16]int]
	Alias17 = SliceFlag[[17]int]
	Alias18 = SliceFlag[[18]int]
	Alias19 = SliceFlag[[19]int]
	Alias20 = SliceFlag[[20]int]
)

  arrayOf(
    // HTTP formats required by RFC2616 but with any timezone:
    // RFC 822, updated by RFC 1123 with any TZ.
    "EEE, dd MMM yyyy HH:mm:ss zzz",
    // RFC 850, obsoleted by RFC 1036 with any TZ.
    "EEEE, dd-MMM-yy HH:mm:ss zzz",
    // ANSI C's asctime() format
    "EEE MMM d HH:mm:ss yyyy",
    // Alternative formats:
    "EEE, dd-MMM-yyyy HH:mm:ss z",
    "EEE, dd-MMM-yyyy HH-mm-ss z",

        buildFile << """
            configurations {
                conf {
                    attributes {
                        def otherAttribute = Attribute.of("zzz", Named)
                        attributeProvider(Attribute.of("aaa", Named), provider {
                            assert getAttribute(otherAttribute).name == "other"
                            objects.named(Named, "value")

        where:
        versionToFind              | expectedPath
        JavaLanguageVersion.of(7)  | "/path/7.9"
        JavaLanguageVersion.of(8)  | "/path/8.0.zzz.foo" // zzz resolves to a real tool version 999
        JavaLanguageVersion.of(14) | "/path/14.0.2+12"
    }

    @Issue("https://github.com/gradle/gradle/issues/17195")

        given:
        server.start()
        buildFile << """
            @ParallelizableTask
            class ParTask extends DefaultTask {
                @TaskAction zzz() { ${server.callFromBuildUsingExpression('name')} }
            }

            task para1(type:ParTask)
            task para2(type:ParTask)
            task parallelTasks(dependsOn:[para1,para2])
        """

    filtered.put("a", 1);
    filtered.put("b", 2);
    assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered);

    try {
      filtered.putAll(ImmutableMap.of("c", 3, "zzz", 4, "b", 5));
      fail();
    } catch (IllegalArgumentException expected) {
    }

    assertEquals(ImmutableMap.of("a", 1, "b", 2), filtered);
  }