int waitingForChangesIndex = out.indexOf(WAITING_FOR_CHANGES_OUTPUT, startIndex)
        if (waitingForChangesIndex == -1) {
            return -1
        }
        def waitingForChangesEndIndex = waitingForChangesIndex + WAITING_FOR_CHANGES_OUTPUT.length()
        def newLine = "\n"
        int endOfLineIndex = out.indexOf(newLine, waitingForChangesEndIndex)
        if (endOfLineIndex == -1) {

        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add(String.class.getMethod("indexOf", String), "rule", "is not annotated with anything.")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:
- Method indexOf(java.lang.String) is not a valid rule method: is not annotated with anything.'''
    }

	podLister corelisters.PodLister
	podSynced cache.InformerSynced

	// podIndexer has the common PodPVC indexer indexer installed To
	// limit iteration over pods to those of interest.
	podIndexer cache.Indexer

	// recorder is used to record events in the API server
	recorder record.EventRecorder

	queue workqueue.TypedRateLimitingInterface[string]
}

class SplitUtils {
    public static LinkedList split(String source) {
        int lastFind = 0;
        int currentFind = 0;
        LinkedList result = new LinkedList();

        while ((currentFind = source.indexOf(" ", lastFind)) != -1) {
            String token = source.substring(lastFind);
            if (currentFind != -1) {
                token = token.substring(0, currentFind - lastFind);
            }

    val uriStripped = uriStrippedCodePoints.indexOf(codePointString) != -1
    if (uriStripped) {
      if (uri.toString() != component.urlString("")) {
        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // If the URI has more escaping than the HttpURL, check that the decoded values still match.
    val uriEscaped = uriEscapedCodePoints.indexOf(codePointString) != -1
    if (uriEscaped) {

            VfsRelativePath.of(spec.searchedPrefix).compareToFirstSegment(child, caseSensitivity)
        } == spec.expectedIndex
        spec.children.each { child ->
            def childIndex = spec.children.indexOf(child)
            def lengthOfCommonPrefix = VfsRelativePath.of(child).lengthOfCommonPrefix(spec.searchedPrefix, caseSensitivity)
            if (childIndex == spec.expectedIndex) {
                assert lengthOfCommonPrefix > 0

            } else {
                final StringBuilder buf = new StringBuilder(100);
                buf.append(tokenUrl);
                if (StringUtil.isNotBlank(tokenReqParams)) {
                    if (tokenUrl.indexOf('?') >= 0) {
                        buf.append('&');
                    } else {
                        buf.append('?');
                    }
                    buf.append(tokenReqParams);
                }

    def setup() {
        requireSwiftToolChain()
    }

    @ToBeFixedForConfigurationCache
    def "adds source dependencies Swift module of main component to Xcode indexer search path"() {
        def fixture = new SwiftAppWithLibrary()

        given:
        buildTestFixture.withBuildInSubDir()
        singleProjectBuild("greeter") {
            buildFile << """

                int index = auth.indexOf(':');
                String user = ( index != -1 ) ? auth.substring(0, index) : auth;
                String password = ( index != -1 ) ? auth.substring(index + 1) : "";
                index = user.indexOf('\\');
                if ( index == -1 )
                    index = user.indexOf('/');

        super(request);
        this.servletPath = servletPath;
    }

    @Override
    public String getServletPath() {
        if (getQueryString() != null && getQueryString().indexOf("SAStruts.method") != -1) {
            return super.getServletPath();
        }
        return servletPath;
    }