// startIdx defines where the iteration starts. If startIdx is a negative
// value or larger than the size of the argument slice the iteration
// will start from the last element.
func GetArgValue(args []Arg, name string, startIdx int) (string, int) {
	if startIdx < 0 || startIdx > len(args)-1 {
		startIdx = len(args) - 1
	}
	for i := startIdx; i >= 0; i-- {
		arg := args[i]
		if arg.Name == name {

		args          []Arg
		name          string
		expectedValue string
		startIdx      int
		expectedIdx   int
	}{
		{
			testName:      "argument exists with non-empty value",
			args:          []Arg{{Name: "a", Value: "a1"}, {Name: "b", Value: "b1"}, {Name: "c", Value: "c1"}},
			name:          "b",
			expectedValue: "b1",
			expectedIdx:   1,
			startIdx:      -1,
		},
		{

     * being already present in that collection.
     * <p>
     * A match means that the first n lines starting at {@code startIdx} match the lines of the
     * expected deprecation warning.  If there are not n lines starting at {@code startIdx} left in
     * the list of lines, then no match is made.
     * <p>
     * As a second side-effect, the last matched deprecation warning is stored in the

	Flush              func()
}

// ViewerDataTraceConsumer returns a TraceConsumer that writes to w. The
// startIdx and endIdx are used for splitting large traces. They refer to
// indexes in the traceEvents output array, not the events in the trace input.
func ViewerDataTraceConsumer(w io.Writer, startIdx, endIdx int64) TraceConsumer {
	allFrames := make(map[string]format.Frame)
	requiredFrames := make(map[string]format.Frame)

		uintptr(unsafe.Pointer(&b[0])) <= uintptr(unsafe.Pointer(&a[len(a)-1]))+(elemSize-1)
}

// startIdx returns the index in haystack where the needle starts.
// prerequisite: the needle must be aliased entirely inside the haystack.
func startIdx[E any](haystack, needle []E) int {
	p := &needle[0]
	for i := range haystack {
		if p == &haystack[i] {
			return i
		}
	}

			var err error
			base, err = d.debugAddr(u, uint64(addrBase), baseIdx)
			if err != nil {
				return nil, err
			}

		case rleStartxEndx:
			startIdx := buf.uint()
			endIdx := buf.uint()

			start, err := d.debugAddr(u, uint64(addrBase), startIdx)
			if err != nil {
				return nil, err
			}
			end, err := d.debugAddr(u, uint64(addrBase), endIdx)
			if err != nil {
				return nil, err
			}

        executor.schedule(action3, 0, TimeUnit.SECONDS)
        thread.blockUntil.started3

        then:
        instant.started3 > instant.completed1
        instant.started3 > instant.started2
    }


    def stopBlocksUntilAllScheduledRunningJobsAreCompleted() {
        given:
        def action1 = {
            instant.started1
            thread.blockUntil.willStop
            thread.block()

        given:
        expectEvent("started1")
        expectEvent("started2")
        buildFile << """
            task block {
                def buildNum = providers.gradleProperty("buildNum")
                doLast {
                    new URL("${getUrl('started')}\${buildNum.get()}").text

                    // Block indefinitely for the daemon to appear busy

        1 * processor.started({ it.id == 2 && it.name == 'Gradle test' }, _)
        1 * processor.started({ it.name == 'ok' && it.className == ATestNGClassWithManyMethods.name }, { it.parentId == 2 })
        1 * processor.started({ it.name == 'ok2' && it.className == ATestNGClassWithManyMethods.name }, { it.parentId == 2 })
        0 * processor.started(_, _)
    }

    void "executes no tests if none of the included test methods match"() {

        def parentId

        when:
        parent.started()
        sibling.started()
        child.started()

        then:
        1 * progressListener.started(!null) >> { ProgressStartEvent event ->
            assert event.description == "parent"
            parentId = event.progressOperationId
        }
        1 * progressListener.started(!null) >> { ProgressStartEvent event ->