this.delegate = delegate;
            this.state = state;
            this.elementType = elementType;
        }

        public C getDelegate(boolean forMutation) {
            if (forMutation) {
                state.assertCanMutate();
            }
            return delegate;
        }

        protected void validateElementType(Object o) {
            if (o != null) {

	asm, generic, err := newAESGCM(key[:])
	if err != nil {
		t.Fatal(err)
	}
	if reflect.TypeOf(asm) == reflect.TypeOf(generic) {
		t.Skipf("no assembly implementation of GCM")
	}

	// generate permutations
	type pair struct{ align, length int }
	lengths := []int{0, 156, 8192, 8193, 8208}
	keySizes := []int{16, 24, 32}
	alignments := []int{0, 1, 2, 3}
	if testing.Short() {
		keySizes = []int{16}

        then:
        TestComponentMetadataRule.instanceCount == 2
        rule1Executed
        rule2Executed

        where:
        rules << [rule1, rule2, "classRule1", "classRule2"].permutations()

    }

    private SpecConfigurableRule addRuleForModule(String notation) {

        succeeds taskName

        then:
        file("build/test.${fileExtension}").md5Hash == expectedHash

        where:
        input << [
            ['DIR1/FILE11.txt', 'dir2/file22.txt', 'DIR3/file33.txt'].permutations(),
            ['zip', 'tar']
        ].combinations()
        files = input[0]
        taskName = input[1]
        taskType = taskName.capitalize()
        fileExtension = taskName

                            }
                        }
                    }
                }
            }
        }

        where:
        [chain, testVariant] << [REPO_TYPES.permutations(), TEST_VARIANTS.keySet()].combinations()
    }

    def "explicit compile configuration selection works for a chain of pure maven dependencies"() {
        given:

        1 * attributeMatcher.isMatching(compatible, requested) >> true

        0 * attributeMatcher._

        where:
        registrationsIndex << (0..3).permutations()
    }

    @Issue("gradle/gradle#7061")
    def "selects chain of transforms that only all the attributes are satisfied"() {

//    V. Raman in Algorithmica (1996) 16, 115-160:
//    This algorithm either needs additional 2n bits or works only if there
//    are enough different elements available to encode some permutations
//    which have to be undone later (so not stable on any input).
//  - All the optimal in-place sorting/merging algorithms I found are either
//    unstable or rely on enough different elements in each step to encode the

		// an outbound listener for each pod in a headless service. There is thus no need to do a SNI match. It saves us from having to
		// generate expensive permutations of the host name just like RDS does..
		// NOTE that we cannot have two services with the same VIP as our listener build logic will treat it as a collision and
		// ignore one of the services.

  /** Non-NPE RuntimeException. */
  public static class FooException extends RuntimeException {
    private static final long serialVersionUID = 1L;
  }

  /**
   * Class for testing all permutations of static/non-static one-argument methods using
   * methodParameter().
   */
  @SuppressWarnings("unused") // used by reflection
  public static class OneArg {

	//   - things work for both referenced and unreferenced params
	//   - things work for named return values un-named return vals
	//
	// The scenarios below don't cover all possible permutations and
	// combinations, but they hit a bunch of the high points.

	const prog = `
package main

// First testcase. All input params in registers, all params used.

//go:noinline