new AmbiguousBindingReporter.Provider("s1", methodDescriptor(ProvidesStringOne, "s1").toString()),
        ]).asString()

        cause.message == message

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

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

        }
    }

package main

var b[10] float32;

func
main() {
	var a[10] float32;

	for i:=int16(5); i<10; i=i+1 {
		a[i] = float32(i);
	}

	s1 := float32(0);
	for i:=5; i<10; i=i+1 {
		s1 = s1 + a[i];
	}

	if s1 != 35 { panic(s1); }

	for i:=int16(5); i<10; i=i+1 {
		b[i] = float32(i);
	}

	s2 := float32(0);
	for i:=5; i<10; i=i+1 {
		s2 = s2 + b[i];
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type S1 struct{}
type S2 struct{}

func _[P *S1|*S2]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}
}

func _[P *S1|S1]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}

	s1 := make([]Elem, len(s))
	copy(s1, s)
	s2 := make([]Elem, len(s))
	copy(s2, s)
	_OrderedSlice(s1)
	sorter(s2)
	ok := true
	if !sliceEq(s1, s2) {
		fmt.Printf("%s: got %v, want %v", name, s1, s2)
		ok = false
	}
	for i := len(s1) - 1; i > 0; i-- {
		if s1[i] < s1[i-1] {
			fmt.Printf("%s: element %d (%v) < element %d (%v)", name, i, s1[i], i-1, s1[i-1])
			ok = false
		}
	}

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

package main

type S1 struct {
	i int
}
type S2 struct {
	i int
}
type S3 struct {
	S1
	S2
}
type S4 struct {
	S3
	S1
}

func main() {
	var s4 S4
	if s4.i != 0 { // .i refers to s4.S1.i, unambiguously
		panic("fail")
	}

	assert.Equal(t, 1, refs("ns1", "s1"))
	manager.RegisterPod(podWithSecrets("ns1", "name2", s1))
	assert.Equal(t, 2, refs("ns1", "s1"))

	manager.UnregisterPod(podWithSecrets("ns1", "name1", s1))
	assert.Equal(t, 1, refs("ns1", "s1"))
	manager.UnregisterPod(podWithSecrets("ns1", "name1", s1))
	assert.Equal(t, 1, refs("ns1", "s1"))
	manager.UnregisterPod(podWithSecrets("ns1", "name2", s1))

        def black = withValues("black")
        def cat = withValues("cat")

        when:
        def zipped = providerFactory.zip(
                providerFactory.zip(big, black) { s1, s2 -> "$s1 $s2" } ,
                cat) { s1, s2 -> "${s1.capitalize()} ${s2}"}

        then:
        zipped instanceof Provider
        zipped.get() == 'Big black cat'
    }

    def "can zip two providers and use null to remove the value"() {

    }
    return dummy;
  }

  @Benchmark
  int hashString_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3, S4);
    }
    return dummy;
  }

  @Benchmark
  int hashMixed_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(I2, S1, D1, S2, I0);

    private static int compareStrings(String s1, String s2) {
        if (s1 == null && s2 == null) {
            return 0;
        }

        if (s1 == null /* && s2 != null */) {
            return -1;
        }

        if (
        /* s1 != null && */ s2 == null) {
            return 1;
        }

        return s1.compareTo(s2);
    }

	}

	// Create a pod with some secrets.
	s1 := secretsToAttach{
		imagePullSecretNames: []string{"s1"},
		containerEnvSecrets: []envSecrets{
			{envVarNames: []string{"s1"}},
			{envVarNames: []string{"s2"}},
			{envFromNames: []string{"s20"}},
		},
	}
	manager.RegisterPod(podWithSecrets("ns1", "name1", s1))
	// Update the pod with a different secrets.
	s2 := secretsToAttach{