( resultCode & 0x0F ));
        writeInt2( questionCount, dst, start + QUESTION_OFFSET );
        writeInt2( answerCount, dst, start + ANSWER_OFFSET );
        writeInt2( authorityCount, dst, start + AUTHORITY_OFFSET );
        writeInt2( additionalCount, dst, start + ADDITIONAL_OFFSET );
        return HEADER_LENGTH;
    }
    int readHeaderWireFormat( byte[] src, int srcIndex ) {

        writeInt2(this.questionCount, dst, start + QUESTION_OFFSET);
        writeInt2(this.answerCount, dst, start + ANSWER_OFFSET);
        writeInt2(this.authorityCount, dst, start + AUTHORITY_OFFSET);
        writeInt2(this.additionalCount, dst, start + ADDITIONAL_OFFSET);
        return HEADER_LENGTH;
    }

		pos++
	}
	return p.output[start:pos]
}

func (p *printer) commentTextAt(start int) string {
	if start < len(p.output) && p.output[start] == tabwriter.Escape {
		start++
	}
	pos := start
	for pos < len(p.output) && p.output[pos] != tabwriter.Escape && !isNL(p.output[pos]) {
		pos++
	}
	return string(p.output[start:pos])
}

func isNL(b byte) bool {
	return b == '\n' || b == '\f'

	type fields struct {
		activeBuckets map[BucketOptions]*bucketMeasurement
		endTime       time.Time
		update2       uint64
		endTime2      time.Time
	}
	start := time.Now()
	m0 := newBucketMeasurement(start)
	m0.incrementBytes(0)
	m1MiBPS := newBucketMeasurement(start)
	m1MiBPS.incrementBytes(oneMiB)

	test1Want := make(map[BucketOptions]Details)

        when:
        renderer.onOutput(start(1))
        console.flush()

        then:
        progressArea.display == []
    }

    def "parent progress operation without message is ignored when renderable child completes"() {
        when:
        renderer.onOutput(start(1))
        renderer.onOutput(start(id: 2, parentId: 1, status: ":foo"))
        renderer.onOutput(start(id: 3, parentId: null, status: ":bar"))

            [fromStringList(), "new ProcessBuilder(command).start()", "", ""],
            [fromStringArray(), "new ProcessBuilder(command)?.start()", "", ""],
        ]
    }

	}

	// Ensure [start,end) is nondecreasing.
	if start > end {
		start, end = end, start
	}

	if start < root.End() && end > root.Pos() {
		if start == end {
			end = start + 1 // empty interval => interval of size 1
		}
		exact = visit(root)

		// Reverse the path:
		for i, l := 0, len(path); i < l/2; i++ {
			path[i], path[l-1-i] = path[l-1-i], path[i]
		}
	} else {

    if (start != nullptr) start->WaitForNotification();
    while (!coord_->ShouldStop() && counter->load() < until) {
      (*counter)++;
      Env::Default()->SleepForMicroseconds(10 * 1000);
    }
    coord_->RequestStop().IgnoreError();
  }
  void SetStatusThread(const Status& status, BlockingCounter* counter,
                       Notification* start) {
    start->WaitForNotification();

	return m.recorder
}

// Start mocks base method.
func (m *MockCgroupNotifier) Start(eventCh chan<- struct{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", eventCh)
}

// Start indicates an expected call of Start.
func (mr *MockCgroupNotifierMockRecorder) Start(eventCh any) *gomock.Call {
	mr.mock.ctrl.T.Helper()

        BuildOperationState operationStateUnderTest

        when:
        def contextUnderTest = operationRunner.start(operationDetailsBuilder)

        then:
        1 * timeProvider.currentTime >> 123L
        1 * listener.start(_, _) >> { BuildOperationDescriptor descriptor, BuildOperationState operationState ->
            descriptorUnderTest = descriptor