},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.timeStr, func(t *testing.T) {
			gott, goterr := Parse(testCase.timeStr)
			if !errors.Is(goterr, testCase.expectedErr) {
				t.Errorf("expected %v, got %v", testCase.expectedErr, goterr)
			}
			if !gott.Equal(testCase.expectedTime) {
				t.Errorf("expected %v, got %v", testCase.expectedTime, gott)
			}
		})
	}

 Filter 1 was used 1 times
 Filter 4 was used 31 times
Testing basn4a16.png: PASS (64 zero samples)
 Filter 0 was used 1 times
 Filter 1 was used 2 times
 Filter 2 was used 1 times
 Filter 4 was used 28 times
Testing basn6a08.png: PASS (160 zero samples)
 Filter 1 was used 1 times
 Filter 4 was used 31 times
Testing basn6a16.png: PASS (1072 zero samples)
 Filter 1 was used 4 times
 Filter 4 was used 28 times

	defer ts.mutex.Unlock()
	return ts.data.Copy(), ts.times.asDurationSinceEpoch(epoch)
}

type times []time.Time

func (t times) copy() times {
	out := make(times, 0, len(t))
	out = append(out, t...)
	return out
}

func (t times) asDurationSinceEpoch(epoch time.Time) []time.Duration {
	out := make([]time.Duration, 0, len(t))
	for _, tm := range t {
		out = append(out, tm.Sub(epoch))
	}
	return out

}

// ParseHeader parses http.TimeFormat with an acceptable
// extension for http.TimeFormat - return time might be zero
// if the timeStr is invalid.
func ParseHeader(timeStr string) (time.Time, error) {
	for _, dateFormat := range httpTimeFormats {
		t, err := time.Parse(dateFormat, timeStr)
		if err == nil {
			return t, nil
		}
	}
	return time.Time{}, ErrMalformedDate
}

				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"int8", ValueOf(int8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := int8(0)
			for v := range s {
				if v.Interface().(int8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},

	}
	if nmake != 1 {
		println("range called makeslice", nmake, "times")
		panic("fail")
	}
	if s != 10 {
		println("wrong sum ranging over makeslice", s)
		panic("fail")
	}
}

func testslice2() {
	n := 0
	nmake = 0
	for range makeslice() {
		n++
	}
	if nmake != 1 {
		println("range called makeslice", nmake, "times")
		panic("fail")
	}
	if n != 5 {

        }
    }

    def "can recompile many times in a row with a changing set of compiler daemons"() {
        expect:
        10.times {
            println("Run $it")
            succeeds("clean", "assemble", "-Pcounter="+it)
        }
    }

    def "can recompile many times in a row with a reused compiler daemon"() {
        expect:
        10.times {
            println("Run $it")

}

// WithSELinuxOptions sets the SELinuxOptions field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the SELinuxOptions field is set to the value of the last call.
func (b *PodSecurityContextApplyConfiguration) WithSELinuxOptions(value *SELinuxOptionsApplyConfiguration) *PodSecurityContextApplyConfiguration {
	b.SELinuxOptions = value

func (b *ContainerStatusApplyConfiguration) WithImageID(value string) *ContainerStatusApplyConfiguration {
	b.ImageID = &value
	return b
}

// WithContainerID sets the ContainerID field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.

}

// WithName sets the Name field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Name field is set to the value of the last call.
func (b *JobTemplateSpecApplyConfiguration) WithName(value string) *JobTemplateSpecApplyConfiguration {
	b.ensureObjectMetaApplyConfigurationExists()
	b.Name = &value
	return b