}
        '''

        expect:
        2.times {
            succeeds "thing"
            result.assertTasksExecutedInOrder ":thing", ":finalizerDep", ":finalizer"
        }
        2.times {
            fails "thing", "-Pthing.broken"
            result.assertTasksExecutedInOrder ":thing", ":finalizerDep", ":finalizer"
        }
        2.times {
            fails "thing", "-PfinalizerDep.broken"

				}
				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")
			}
		}},

        """

        expect:
        2.times {
            succeeds 'a'
            result.assertTasksExecutedInOrder(
                any(
                    exact(':f', ':h'),
                    exact(any(':c', ':g'), ':a'),
                    exact(':f', ':d', ':c')
                )
            )
        }

        and:
        2.times {
            succeeds 'b'

        }
    }

    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.

#include "src${sourceIdx}_h.h"

<% includedHeaderCount.times { %>
#include "src${it}_h.h"
<% } %>

<% includedCommonHeaderCount.times { %>
#include "common/include/header${it}.h"
<% } %>

#include <stdio.h>

<% functionCount.times { %>
int C_function_${(it+1)+offset} () {
  printf("Hello world!");
  return 0;
}

}

// WithCapacity sets the Capacity 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 Capacity field is set to the value of the last call.
func (b *NodeStatusApplyConfiguration) WithCapacity(value v1.ResourceList) *NodeStatusApplyConfiguration {
	b.Capacity = &value
	return b
}

            Spy(DefaultBuildOperationQueueTest.Success)
        ]

        when:
        async {
            numberOfQueues.times { i ->
                workerThread {
                    buildOperationExecutor.runAll(worker, { queue ->
                        amountOfWork.times {
                            queue.add(operations[i])
                        }
                    })
                }
            }

<% projectDeps.each { p ->
  sourceFiles.times { %>
#include "${p}lib${it + 1}.h"
<%
  }
} %>

<% functionCount.times { %>
long CPP_${functionName}_${it + 1} () {
  long sum = 1;
  // Call functions defined in dependent projects.
  <% projectDeps.each { p ->
    sourceFiles.times {
      def functionName = "${p}lib${it + 1}"
      functionCount.times {
  %>
  sum += CPP_${functionName}_${it + 1}();
  <%