]).asString()

        cause.message == message

        where:
        order << [ProvidesStringOne, ProvidesStringTwo, MutatesString].permutations()
    }

    static class MutatesS1AsInteger extends RuleSource {
        @Mutate
        void m(@Path("s1") Integer s1) {

        }
    }

  public void testOfferedKPlusOne() {
    for (List<Integer> list : Collections2.permutations(Ints.asList(1, 2, 3, 4, 5))) {
      TopKSelector<Integer> top = TopKSelector.least(4);
      top.offerAll(list);
      assertThat(top.topK()).containsExactly(1, 2, 3, 4).inOrder();
    }
  }

  public void testOfferedThreeK() {
    for (List<Integer> list : Collections2.permutations(Ints.asList(1, 2, 3, 4, 5, 6))) {

        // This method generates all permutations so we can assert we have at least one
        def attributesPermutations = { String template, List<String> attributes ->
            def permutations = []
            attributes.eachPermutation { attrs ->
                permutations << template.replace('##ATTRIBUTES##', attrs.join(' '))
            }
            permutations
        }
        switch (version) {

// errorcheck

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test various correct and incorrect permutations of send-only,
// receive-only, and bidirectional channels.
// Does not compile.

package main

var (
	cr <-chan int
	cs chan<- int
	c  chan int
)

func main() {
	cr = c  // ok
	cs = c  // ok

        when:
        spec.assertMatches(-1, executedTasks)

        then:
        thrown(AssertionError)

        where:
        executedTasks << [':a', ':b', ':c'].permutations().findAll { it != [':a', ':b', ':c'] } + [
            [':a', ':c'],
            [':a', ':b'],
            [':b', ':c'],
            [':a', ':c', ':b', ':d'],
            [':z', ':b', ':a', ':c'],

		uint64(s[11]))<<4|
		uint64(s[12]))<<4|
		uint64(s[13]))<<4|
		uint64(s[14]))<<4 |
		uint64(s[15]))
	return r
}

// Compute the determinant of a 4x4-matrix by the sum
// over all index permutations.
func determinant(m [4][4]float64) float64 {
	return m[0][0]*m[1][1]*m[2][2]*m[3][3] -
		m[0][0]*m[1][1]*m[2][3]*m[3][2] -
		m[0][0]*m[1][2]*m[2][1]*m[3][3] +
		m[0][0]*m[1][2]*m[2][3]*m[3][1] +

// license that can be found in the LICENSE file.

package p

// Constraint type inference should be independent of the
// ordering of the type parameter declarations. Try all
// permutations in the test case below.
// Permutations produced by https://go.dev/play/p/PHcZNGJTEBZ.

func f00[S1 ~[]E1, S2 ~[]E2, E1 ~byte, E2 ~byte](S1, S2) {}
func f01[S2 ~[]E2, S1 ~[]E1, E1 ~byte, E2 ~byte](S1, S2) {}

            }

            apply plugin: "${plugins[1]}"
        """

        then:
        succeeds "clean"

        where:
        plugins << [QUALIFIED_JAVA, UNQUALIFIED_JAVA].permutations()
    }

        }
        indexes.each {
            selectors.remove(candidateSelectors[it])
        }

        then:
        verifyEmpty(selectors)

        where:
        indexes << [0, 1, 2, 3].permutations()

    }

    def "sorts selectors for faster selection"() {
        given:
        def dynamic1 = dynamicSelector()
        def dynamic2 = dynamicSelector()
        def latest = latestSelector()

                                   new GradleDependency('Tooling API', 'implementation', "'org.gradle:gradle-tooling-api'")].permutations()
    }

    static void writeClassesInZipFileToTextFile(File zipFile, File txtFile) {
        IoActions.withResource(new ZipInputStream(new FileInputStream(zipFile)), new ErroringAction<ZipInputStream>() {